diff --git a/css/OverlayScrollbars.css b/css/OverlayScrollbars.css index 4c9e0f2..f9e794d 100644 --- a/css/OverlayScrollbars.css +++ b/css/OverlayScrollbars.css @@ -2,13 +2,13 @@ * OverlayScrollbars * https://github.com/KingSora/OverlayScrollbars * - * Version: 1.4.1 - * + * Version: 1.4.2 + * * Copyright KingSora. * https://github.com/KingSora * * Released under the MIT license. - * Date: 22.03.2018 + * Date: 14.04.2018 */ /* diff --git a/css/OverlayScrollbars.min.css b/css/OverlayScrollbars.min.css index 50feff2..953664e 100644 --- a/css/OverlayScrollbars.min.css +++ b/css/OverlayScrollbars.min.css @@ -2,12 +2,12 @@ * OverlayScrollbars * https://github.com/KingSora/OverlayScrollbars * - * Version: 1.4.1 - * + * Version: 1.4.2 + * * Copyright KingSora. * https://github.com/KingSora * * Released under the MIT license. - * Date: 22.03.2018 + * Date: 14.04.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}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}#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.os-viewport::-webkit-scrollbar,.os-viewport-native-scrollbars-invisible#hs-dummy-scrollbar-size::-webkit-scrollbar-corner,.os-viewport-native-scrollbars-invisible.os-viewport::-webkit-scrollbar-corner{display:none!important;width:0!important;height:0!important;visibility:hidden!important;background:transparent!important}.os-content-glue{max-height:100%;max-width:100%;width:100%;pointer-events:none}.os-padding{direction:inherit;position:absolute;overflow:visible;padding:0;margin:0;left:0;top:0;bottom:0;right:0;width:auto!important;height:auto!important;z-index:1}.os-host-overflow > .os-padding{overflow:hidden}.os-viewport{direction:inherit!important;box-sizing:inherit!important;resize:none!important;position:absolute;overflow:hidden;top:0;left:0;bottom:0;right:0;padding:0;margin:0;-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%;height:100%;width:100%;visibility:visible}.os-host-textarea > .os-padding > .os-content{overflow:hidden!important}.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:transparent!important;outline:0 none transparent!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:inherit;border-color:transparent;border-style:solid;box-sizing:border-box}.os-resize-observer-host:after{content:''}.os-resize-observer-host > .os-resize-observer,.os-resize-observer-host:after{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}.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:.001s;animation-duration:.001s;-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 0.3s,visibility 0.3s,top 0.3s,right 0.3s,bottom 0.3s,left .3s;transition:opacity 0.3s,visibility 0.3s,top 0.3s,right 0.3s,bottom 0.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-track{pointer-events:auto;position:relative;height:100%;width:100%;padding:0!important;border:none!important}.os-scrollbar-handle{pointer-events:auto;position:absolute;width:100%;height:100%}.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-vertical{right:auto;left:0}.os-host-rtl > .os-scrollbar-corner{right:auto;left:0}.os-scrollbar-auto-hidden,.os-padding + .os-scrollbar-corner,.os-host-resize-disabled.os-host-scrollbar-horizontal-hidden > .os-scrollbar-corner,.os-host-scrollbar-horizontal-hidden > .os-scrollbar-horizontal,.os-host-resize-disabled.os-host-scrollbar-vertical-hidden > .os-scrollbar-corner,.os-host-scrollbar-vertical-hidden > .os-scrollbar-vertical,.os-scrollbar-horizontal.os-scrollbar-auto-hidden + .os-scrollbar-vertical + .os-scrollbar-corner,.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-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{right:0;left:0}.os-scrollbar:hover,.os-scrollbar-corner.os-scrollbar-corner-resize{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-horizontal,.os-theme-none > .os-scrollbar-vertical,.os-theme-none > .os-scrollbar-corner{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:transparent}.os-theme-dark > .os-scrollbar.os-scrollbar-unusable,.os-theme-light > .os-scrollbar.os-scrollbar-unusable{background:transparent}.os-theme-dark > .os-scrollbar > .os-scrollbar-track,.os-theme-light > .os-scrollbar > .os-scrollbar-track{background:transparent}.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-scrollbar > .os-scrollbar-track > .os-scrollbar-handle,.os-theme-light > .os-scrollbar > .os-scrollbar-track > .os-scrollbar-handle{border-radius:11px;opacity:.4}.os-theme-dark > .os-scrollbar > .os-scrollbar-track > .os-scrollbar-handle{background:#000}.os-theme-light > .os-scrollbar > .os-scrollbar-track > .os-scrollbar-handle{background:#fff}.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:opacity .3s;transition:opacity .3s}.os-theme-dark > .os-scrollbar:hover > .os-scrollbar-track > .os-scrollbar-handle,.os-theme-light > .os-scrollbar:hover > .os-scrollbar-track > .os-scrollbar-handle{opacity:.55}.os-theme-dark > .os-scrollbar > .os-scrollbar-track > .os-scrollbar-handle.active,.os-theme-light > .os-scrollbar > .os-scrollbar-track > .os-scrollbar-handle.active{opacity:.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/js/OverlayScrollbars.js b/js/OverlayScrollbars.js index a73fbdf..8a3116e 100644 --- a/js/OverlayScrollbars.js +++ b/js/OverlayScrollbars.js @@ -2,5914 +2,5818 @@ * OverlayScrollbars * https://github.com/KingSora/OverlayScrollbars * - * Version: 1.4.1 - * + * Version: 1.4.2 + * * Copyright KingSora. * https://github.com/KingSora * * Released under the MIT license. - * Date: 22.03.2018 + * Date: 14.04.2018 */ (function (global, factory) { - if (typeof define === 'function' && define.amd) - define(function() { return factory(global, global.document, undefined); }); - else if (typeof exports === 'object') + //if (typeof define === 'function' && define.amd) + // define(function() { return factory(global, global.document, undefined); }); + if (typeof module === 'object' && typeof module.exports === 'object') module.exports = factory(global, global.document, undefined); else factory(global, global.document, undefined); -}(typeof window !== 'undefined' ? window : this, (function(window, document, undefined) { - 'use-strict'; - var PLUGINNAME = 'OverlayScrollbars'; - - var TYPES = { - o : 'object', - f : 'function', - a : 'array', - s : 'string', - n : 'number', - u : 'undefined' - }; - var WORDING = { - c : 'class', - s : 'style', - i : 'id', - oH : 'offsetHeight', - cH : 'clientHeight', - sH : 'scrollHeight', - oW : 'offsetWidth', - cW : 'clientWidth', - sW : 'scrollWidth' - }; - var COMPATIBILITY = { - /** - * Gets the current window width. - * @returns {Number|number} The current window width in pixel. - */ - wW: function() { - return window.innerWidth || document.documentElement[WORDING.cW] || document.body[WORDING.cW]; - }, - - /** - * Gets the current window height. - * @returns {Number|number} The current window height in pixel. - */ - wH: function() { - return window.innerHeight || document.documentElement[WORDING.cH] || document.body[WORDING.cH]; - }, - - /** - * Gets the MutationObserver Object or undefined if not supported. - * @returns {MutationObserver|*|undefined} The MutationsObserver Object or undefined. - */ - mO: function() { - return window.MutationObserver || window.WebKitMutationObserver || window.WebkitMutationObserver || window.MozMutationObserver || undefined; - }, - - /** - * Gets the ResizeObserver Object or undefined if not supported. - * @returns {MutationObserver|*|undefined} The ResizeObserver Object or undefined. - */ - rO: function() { - return window.ResizeObserver || window.WebKitResizeObserver || window.WebkitResizeObserver || window.MozResizeObserver || undefined; - }, - - /** - * Gets the RequestAnimationFrame method or it's corresponding polyfill. - * @returns {*|Function} The RequestAnimationFrame method or it's corresponding polyfill. - */ - rAF: function() { - return window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function (func) { - return window.setTimeout(func, 1000 / 60); - }; - }, - - /** - * Gets the CancelAnimationFrame method or it's corresponding polyfill. - * @returns {*|Function} The CancelAnimationFrame method or it's corresponding polyfill. - */ - cAF: function() { - return window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || window.oCancelAnimationFrame || window.msCancelAnimationFrame || function (id) { - return window.clearTimeout(id); - }; - }, - - /** - * Gets the current time. - * @returns {number} The current time. - */ - now: function() { - return Date.now() || new Date().getTime(); - }, - - /** - * Stops the propagation of the given event. - * @param e The event of which the propagation shall be stoped. - */ - stpP: function(e) { - if(e.stopPropagation) - e.stopPropagation(); - else - e.cancelBubble = true; - }, - - /** - * Prevents the default action of the given event. - * @param e The event of which the default action shall be prevented. - */ - prvD: function(e) { - if(e.preventDefault) - e.preventDefault(); - else - e.returnValue = false; - }, - - /** - * Gets the pageX and pageY values of the given mouse event. - * @param e The mouse event of which the pageX and pageX shall be got. - * @returns {x: number, y: number} x = pageX value, y = pageY value. - */ - page: function(e) { - e = e.originalEvent || e; - - var strPage = 'page'; - var strClient = 'client'; - var strX = 'X'; - var strY = 'Y'; - var target = e.target || e.srcElement || document; - var eventDoc = target.ownerDocument || document; - var doc = eventDoc.documentElement; - var body = eventDoc.body; - - //if touch event return return pageX/Y of it - if(e.touches !== undefined) { - var touch = e.touches[0]; - return { - x : touch[strPage + strX], - y : touch[strPage + strY] - } - } - - // Calculate pageX/Y if not native supported - if (!e[strPage + strX] && e[strClient + strX] && e[strClient + strX] != null) { - - return { - x : e[strClient + strX] + - (doc && doc.scrollLeft || body && body.scrollLeft || 0) - - (doc && doc.clientLeft || body && body.clientLeft || 0), - y : e[strClient + strY] + - (doc && doc.scrollTop || body && body.scrollTop || 0) - - (doc && doc.clientTop || body && body.clientTop || 0) - } - } - return { - x : e[strPage + strX], - y : e[strPage + strY] - }; - }, - - /** - * Gets the clicked mouse button of the given mouse event. - * @param e The mouse event of which the clicked button shal be got. - * @returns {number} The number of the clicked mouse button. (1 : leftButton | 2 : middleButton | 3 : rightButton) - */ - mBtn: function(e) { - if (!e.which && e.button !== undefined) - return (e.button & 1 ? 1 : (e.button & 2 ? 3 : (e.button & 4 ? 2 : 0))); - else - return e.which; - }, - - bind: function(func, oThis) { - if (typeof func !== TYPES.f) { - throw "Can't bind function!"; - // closest thing possible to the ECMAScript 5 - // internal IsCallable function - //throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable'); - } - - var aArgs = Array.prototype.slice.call(arguments, 2); - var fNOP = function() {}; - var fBound = function() { return func.apply(this instanceof fNOP ? this : oThis, aArgs.concat(Array.prototype.slice.call(arguments))); }; - - if (func.prototype) - fNOP.prototype = func.prototype; // Function.prototype doesn't have a prototype property - fBound.prototype = new fNOP(); - - return fBound; - } - }; - var HELPER = (function(compatibility) { - var _rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g ); - var _toStr = Object.prototype.toString; - var _strSpace = ' '; - var _strEmpty = ''; - var _animations = [ ]; - var _cssNumber = { - "animationIterationCount": true, - "columnCount": true, - "fillOpacity": true, - "flexGrow": true, - "flexShrink": true, - "fontWeight": true, - "lineHeight": true, - "opacity": true, - "order": true, - "orphans": true, - "widows": true, - "zIndex": true, - "zoom": true +}(typeof window !== 'undefined' ? window : this, + function(window, document, undefined) { + 'use strict'; + var PLUGINNAME = 'OverlayScrollbars'; + var TYPES = { + o : 'object', + f : 'function', + a : 'array', + s : 'string', + b : 'boolean', + n : 'number', + u : 'undefined', + z : 'null' + //d : 'date', + //e : 'error', + //r : 'regexp', + //y : 'symbol' }; - var _easings = { - /* - x : current percent (0 - 1), - t : current time (duration * percent), - b : start value (from), - c : end value (to), - d : duration - - easingName : function(x, t, b, c, d) { return easedValue; } + var LEXICON = { + c : 'class', + s : 'style', + i : 'id', + oH : 'offsetHeight', + cH : 'clientHeight', + sH : 'scrollHeight', + oW : 'offsetWidth', + cW : 'clientWidth', + sW : 'scrollWidth' + }; + var COMPATIBILITY = { + /** + * Gets the current window width. + * @returns {Number|number} The current window width in pixel. */ + wW: function() { + return window.innerWidth || document.documentElement[LEXICON.cW] || document.body[LEXICON.cW]; + }, - swing: function (x, t, b, c, d) { - return 0.5 - Math.cos(x * Math.PI) / 2; + /** + * Gets the current window height. + * @returns {Number|number} The current window height in pixel. + */ + wH: function() { + return window.innerHeight || document.documentElement[LEXICON.cH] || document.body[LEXICON.cH]; }, - linear: function(x, t, b, c, d) { - return x; + + /** + * Gets the MutationObserver Object or undefined if not supported. + * @returns {MutationObserver|*|undefined} The MutationsObserver Object or undefined. + */ + mO: function() { + return window.MutationObserver || window.WebKitMutationObserver || window.WebkitMutationObserver || window.MozMutationObserver || undefined; }, - easeInQuad: function (x, t, b, c, d) { - return c*(t/=d)*t + b; + + /** + * Gets the ResizeObserver Object or undefined if not supported. + * @returns {MutationObserver|*|undefined} The ResizeObserver Object or undefined. + */ + rO: function() { + return window.ResizeObserver || window.WebKitResizeObserver || window.WebkitResizeObserver || window.MozResizeObserver || undefined; }, - easeOutQuad: function (x, t, b, c, d) { - return -c *(t/=d)*(t-2) + b; + + /** + * Gets the RequestAnimationFrame method or it's corresponding polyfill. + * @returns {*|Function} The RequestAnimationFrame method or it's corresponding polyfill. + */ + rAF: function() { + return window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function (func) { + return window.setTimeout(func, 1000 / 60); + }; }, - easeInOutQuad: function (x, t, b, c, d) { - if ((t/=d/2) < 1) return c/2*t*t + b; - return -c/2 * ((--t)*(t-2) - 1) + b; + + /** + * Gets the CancelAnimationFrame method or it's corresponding polyfill. + * @returns {*|Function} The CancelAnimationFrame method or it's corresponding polyfill. + */ + cAF: function() { + return window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || window.oCancelAnimationFrame || window.msCancelAnimationFrame || function (id) { + return window.clearTimeout(id); + }; }, - easeInCubic: function (x, t, b, c, d) { - return c*(t/=d)*t*t + b; + + /** + * Gets the current time. + * @returns {number} The current time. + */ + now: function() { + return Date.now() || new Date().getTime(); }, - easeOutCubic: function (x, t, b, c, d) { - return c*((t=t/d-1)*t*t + 1) + b; + + /** + * Stops the propagation of the given event. + * @param e The event of which the propagation shall be stoped. + */ + stpP: function(e) { + if(e.stopPropagation) + e.stopPropagation(); + else + e.cancelBubble = true; }, - easeInOutCubic: function (x, t, b, c, d) { - if ((t/=d/2) < 1) return c/2*t*t*t + b; - return c/2*((t-=2)*t*t + 2) + b; + + /** + * Prevents the default action of the given event. + * @param e The event of which the default action shall be prevented. + */ + prvD: function(e) { + if(e.preventDefault) + e.preventDefault(); + else + e.returnValue = false; }, - easeInQuart: function (x, t, b, c, d) { - return c*(t/=d)*t*t*t + b; - }, - easeOutQuart: function (x, t, b, c, d) { - return -c * ((t=t/d-1)*t*t*t - 1) + b; - }, - easeInOutQuart: function (x, t, b, c, d) { - if ((t/=d/2) < 1) return c/2*t*t*t*t + b; - return -c/2 * ((t-=2)*t*t*t - 2) + b; - }, - easeInQuint: function (x, t, b, c, d) { - return c*(t/=d)*t*t*t*t + b; - }, - easeOutQuint: function (x, t, b, c, d) { - return c*((t=t/d-1)*t*t*t*t + 1) + b; - }, - easeInOutQuint: function (x, t, b, c, d) { - if ((t/=d/2) < 1) return c/2*t*t*t*t*t + b; - return c/2*((t-=2)*t*t*t*t + 2) + b; - }, - easeInSine: function (x, t, b, c, d) { - return -c * Math.cos(t/d * (Math.PI/2)) + c + b; - }, - easeOutSine: function (x, t, b, c, d) { - return c * Math.sin(t/d * (Math.PI/2)) + b; - }, - easeInOutSine: function (x, t, b, c, d) { - return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b; - }, - easeInExpo: function (x, t, b, c, d) { - return (t==0) ? b : c * Math.pow(2, 10 * (t/d - 1)) + b; - }, - easeOutExpo: function (x, t, b, c, d) { - return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b; - }, - easeInOutExpo: function (x, t, b, c, d) { - if (t==0) return b; - if (t==d) return b+c; - if ((t/=d/2) < 1) return c/2 * Math.pow(2, 10 * (t - 1)) + b; - return c/2 * (-Math.pow(2, -10 * --t) + 2) + b; - }, - easeInCirc: function (x, t, b, c, d) { - return -c * (Math.sqrt(1 - (t/=d)*t) - 1) + b; - }, - easeOutCirc: function (x, t, b, c, d) { - return c * Math.sqrt(1 - (t=t/d-1)*t) + b; - }, - easeInOutCirc: function (x, t, b, c, d) { - if ((t/=d/2) < 1) return -c/2 * (Math.sqrt(1 - t*t) - 1) + b; - return c/2 * (Math.sqrt(1 - (t-=2)*t) + 1) + b; - }, - easeInElastic: function (x, t, b, c, d) { - var s=1.70158;var p=0;var a=c; - if (t==0) return b; if ((t/=d)==1) return b+c; if (!p) p=d*.3; - if (a < Math.abs(c)) { a=c; var s=p/4; } - else var s = p/(2*Math.PI) * Math.asin (c/a); - return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b; - }, - easeOutElastic: function (x, t, b, c, d) { - var s=1.70158;var p=0;var a=c; - if (t==0) return b; if ((t/=d)==1) return b+c; if (!p) p=d*.3; - if (a < Math.abs(c)) { a=c; var s=p/4; } - else var s = p/(2*Math.PI) * Math.asin (c/a); - return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b; - }, - easeInOutElastic: function (x, t, b, c, d) { - var s=1.70158;var p=0;var a=c; - if (t==0) return b; if ((t/=d/2)==2) return b+c; if (!p) p=d*(.3*1.5); - if (a < Math.abs(c)) { a=c; var s=p/4; } - else var s = p/(2*Math.PI) * Math.asin (c/a); - if (t < 1) return -.5*(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b; - return a*Math.pow(2,-10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )*.5 + c + b; - }, - easeInBack: function (x, t, b, c, d, s) { - if (s == undefined) s = 1.70158; - return c*(t/=d)*t*((s+1)*t - s) + b; - }, - easeOutBack: function (x, t, b, c, d, s) { - if (s == undefined) s = 1.70158; - return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b; - }, - easeInOutBack: function (x, t, b, c, d, s) { - if (s == undefined) s = 1.70158; - if ((t/=d/2) < 1) return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b; - return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b; - }, - easeInBounce: function (x, t, b, c, d) { - return c - this.easeOutBounce (x, d-t, 0, c, d) + b; - }, - easeOutBounce: function (x, t, b, c, d) { - if ((t/=d) < (1/2.75)) { - return c*(7.5625*t*t) + b; - } else if (t < (2/2.75)) { - return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b; - } else if (t < (2.5/2.75)) { - return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b; - } else { - return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b; + + /** + * Gets the pageX and pageY values of the given mouse event. + * @param e The mouse event of which the pageX and pageX shall be got. + * @returns {x: number, y: number} x = pageX value, y = pageY value. + */ + page: function(e) { + e = e.originalEvent || e; + + var strPage = 'page'; + var strClient = 'client'; + var strX = 'X'; + var strY = 'Y'; + var target = e.target || e.srcElement || document; + var eventDoc = target.ownerDocument || document; + var doc = eventDoc.documentElement; + var body = eventDoc.body; + + //if touch event return return pageX/Y of it + if(e.touches !== undefined) { + var touch = e.touches[0]; + return { + x : touch[strPage + strX], + y : touch[strPage + strY] + } } + + // Calculate pageX/Y if not native supported + if (!e[strPage + strX] && e[strClient + strX] && e[strClient + strX] != null) { + + return { + x : e[strClient + strX] + + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - + (doc && doc.clientLeft || body && body.clientLeft || 0), + y : e[strClient + strY] + + (doc && doc.scrollTop || body && body.scrollTop || 0) - + (doc && doc.clientTop || body && body.clientTop || 0) + } + } + return { + x : e[strPage + strX], + y : e[strPage + strY] + }; }, - easeInOutBounce: function (x, t, b, c, d) { - if (t < d/2) return this.easeInBounce (x, t*2, 0, c, d) * .5 + b; - return this.easeOutBounce (x, t*2-d, 0, c, d) * .5 + c*.5 + b; + + /** + * Gets the clicked mouse button of the given mouse event. + * @param e The mouse event of which the clicked button shal be got. + * @returns {number} The number of the clicked mouse button. (1 : leftButton | 2 : middleButton | 3 : rightButton) + */ + mBtn: function(e) { + if (!e.which && e.button !== undefined) + return (e.button & 1 ? 1 : (e.button & 2 ? 3 : (e.button & 4 ? 2 : 0))); + else + return e.which; + }, + + bind: function(func, oThis) { + if (typeof func !== TYPES.f) { + throw "Can't bind function!"; + // closest thing possible to the ECMAScript 5 + // internal IsCallable function + //throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable'); + } + + var aArgs = Array.prototype.slice.call(arguments, 2); + var fNOP = function() {}; + var fBound = function() { return func.apply(this instanceof fNOP ? this : oThis, aArgs.concat(Array.prototype.slice.call(arguments))); }; + + if (func.prototype) + fNOP.prototype = func.prototype; // Function.prototype doesn't have a prototype property + fBound.prototype = new fNOP(); + + return fBound; } }; - var FakejQuery = function (selector) { - var jQQ = FakejQuery; - var elments; - var elms; - var el; - var i = 0; - if(jQQ.type(selector) === TYPES.s) { - elments = [ ]; - elms; - if(selector.charAt(0) === '<') { - el = document.createElement('div'); - el.innerHTML = selector; - elms = el.children; + var FRAMEWORK = (function(compatibility) { + var _rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g ); + var _toStr = Object.prototype.toString; + var _strSpace = ' '; + var _strEmpty = ''; + var _animations = [ ]; + var _cssNumber = { + "animationIterationCount": true, + "columnCount": true, + "fillOpacity": true, + "flexGrow": true, + "flexShrink": true, + "fontWeight": true, + "lineHeight": true, + "opacity": true, + "order": true, + "orphans": true, + "widows": true, + "zIndex": true, + "zoom": true + }; + var _easings = { + /* + x : current percent (0 - 1), + t : current time (duration * percent), + b : start value (from), + c : end value (to), + d : duration + + easingName : function(x, t, b, c, d) { return easedValue; } + */ + + swing: function (x, t, b, c, d) { + return 0.5 - Math.cos(x * Math.PI) / 2; + }, + linear: function(x, t, b, c, d) { + return x; + }, + easeInQuad: function (x, t, b, c, d) { + return c*(t/=d)*t + b; + }, + easeOutQuad: function (x, t, b, c, d) { + return -c *(t/=d)*(t-2) + b; + }, + easeInOutQuad: function (x, t, b, c, d) { + if ((t/=d/2) < 1) return c/2*t*t + b; + return -c/2 * ((--t)*(t-2) - 1) + b; + }, + easeInCubic: function (x, t, b, c, d) { + return c*(t/=d)*t*t + b; + }, + easeOutCubic: function (x, t, b, c, d) { + return c*((t=t/d-1)*t*t + 1) + b; + }, + easeInOutCubic: function (x, t, b, c, d) { + if ((t/=d/2) < 1) return c/2*t*t*t + b; + return c/2*((t-=2)*t*t + 2) + b; + }, + easeInQuart: function (x, t, b, c, d) { + return c*(t/=d)*t*t*t + b; + }, + easeOutQuart: function (x, t, b, c, d) { + return -c * ((t=t/d-1)*t*t*t - 1) + b; + }, + easeInOutQuart: function (x, t, b, c, d) { + if ((t/=d/2) < 1) return c/2*t*t*t*t + b; + return -c/2 * ((t-=2)*t*t*t - 2) + b; + }, + easeInQuint: function (x, t, b, c, d) { + return c*(t/=d)*t*t*t*t + b; + }, + easeOutQuint: function (x, t, b, c, d) { + return c*((t=t/d-1)*t*t*t*t + 1) + b; + }, + easeInOutQuint: function (x, t, b, c, d) { + if ((t/=d/2) < 1) return c/2*t*t*t*t*t + b; + return c/2*((t-=2)*t*t*t*t + 2) + b; + }, + easeInSine: function (x, t, b, c, d) { + return -c * Math.cos(t/d * (Math.PI/2)) + c + b; + }, + easeOutSine: function (x, t, b, c, d) { + return c * Math.sin(t/d * (Math.PI/2)) + b; + }, + easeInOutSine: function (x, t, b, c, d) { + return -c/2 * (Math.cos(Math.PI*t/d) - 1) + b; + }, + easeInExpo: function (x, t, b, c, d) { + return (t==0) ? b : c * Math.pow(2, 10 * (t/d - 1)) + b; + }, + easeOutExpo: function (x, t, b, c, d) { + return (t==d) ? b+c : c * (-Math.pow(2, -10 * t/d) + 1) + b; + }, + easeInOutExpo: function (x, t, b, c, d) { + if (t==0) return b; + if (t==d) return b+c; + if ((t/=d/2) < 1) return c/2 * Math.pow(2, 10 * (t - 1)) + b; + return c/2 * (-Math.pow(2, -10 * --t) + 2) + b; + }, + easeInCirc: function (x, t, b, c, d) { + return -c * (Math.sqrt(1 - (t/=d)*t) - 1) + b; + }, + easeOutCirc: function (x, t, b, c, d) { + return c * Math.sqrt(1 - (t=t/d-1)*t) + b; + }, + easeInOutCirc: function (x, t, b, c, d) { + if ((t/=d/2) < 1) return -c/2 * (Math.sqrt(1 - t*t) - 1) + b; + return c/2 * (Math.sqrt(1 - (t-=2)*t) + 1) + b; + }, + easeInElastic: function (x, t, b, c, d) { + var s=1.70158;var p=0;var a=c; + if (t==0) return b; if ((t/=d)==1) return b+c; if (!p) p=d*.3; + if (a < Math.abs(c)) { a=c; var s=p/4; } + else var s = p/(2*Math.PI) * Math.asin (c/a); + return -(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b; + }, + easeOutElastic: function (x, t, b, c, d) { + var s=1.70158;var p=0;var a=c; + if (t==0) return b; if ((t/=d)==1) return b+c; if (!p) p=d*.3; + if (a < Math.abs(c)) { a=c; var s=p/4; } + else var s = p/(2*Math.PI) * Math.asin (c/a); + return a*Math.pow(2,-10*t) * Math.sin( (t*d-s)*(2*Math.PI)/p ) + c + b; + }, + easeInOutElastic: function (x, t, b, c, d) { + var s=1.70158;var p=0;var a=c; + if (t==0) return b; if ((t/=d/2)==2) return b+c; if (!p) p=d*(.3*1.5); + if (a < Math.abs(c)) { a=c; var s=p/4; } + else var s = p/(2*Math.PI) * Math.asin (c/a); + if (t < 1) return -.5*(a*Math.pow(2,10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )) + b; + return a*Math.pow(2,-10*(t-=1)) * Math.sin( (t*d-s)*(2*Math.PI)/p )*.5 + c + b; + }, + easeInBack: function (x, t, b, c, d, s) { + if (s == undefined) s = 1.70158; + return c*(t/=d)*t*((s+1)*t - s) + b; + }, + easeOutBack: function (x, t, b, c, d, s) { + if (s == undefined) s = 1.70158; + return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b; + }, + easeInOutBack: function (x, t, b, c, d, s) { + if (s == undefined) s = 1.70158; + if ((t/=d/2) < 1) return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b; + return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b; + }, + easeInBounce: function (x, t, b, c, d) { + return c - this.easeOutBounce (x, d-t, 0, c, d) + b; + }, + easeOutBounce: function (x, t, b, c, d) { + if ((t/=d) < (1/2.75)) { + return c*(7.5625*t*t) + b; + } else if (t < (2/2.75)) { + return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b; + } else if (t < (2.5/2.75)) { + return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b; + } else { + return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b; + } + }, + easeInOutBounce: function (x, t, b, c, d) { + if (t < d/2) return this.easeInBounce (x, t*2, 0, c, d) * .5 + b; + return this.easeOutBounce (x, t*2-d, 0, c, d) * .5 + c*.5 + b; + } + }; + + var extend = function() { + var src, copyIsArray, copy, name, options, clone, target = arguments[0] || {}, + i = 1, + length = arguments.length, + deep = false; + + // Handle a deep copy situation + if (typeof target === "boolean") { + deep = target; + target = arguments[1] || {}; + // skip the boolean and the target + i = 2; + } + + // Handle case when target is a string or something (possible in deep copy) + if (typeof target !== TYPES.o && !type(target) === TYPES.f) { + target = {}; + } + + // extend jQuery itself if only one argument is passed + if (length === i) { + target = FakejQuery; + --i; + } + + for (; i < length; i++) { + // Only deal with non-null/undefined values + if ((options = arguments[i]) != null) { + // Extend the base object + for (name in options) { + src = target[name]; + copy = options[name]; + + // Prevent never-ending loop + if (target === copy) { + continue; + } + + // Recurse if we're merging plain objects or arrays + if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) { + if (copyIsArray) { + copyIsArray = false; + clone = src && isArray(src) ? src : []; + + } else { + clone = src && isPlainObject(src) ? src : {}; + } + + // Never move original objects, clone them + target[name] = extend(deep, clone, copy); + + // Don't bring in undefined values + } else if (copy !== undefined) { + target[name] = copy; + } + } + } + } + + // Return the modified object + return target; + }; + + var type = function(obj) { + if (obj === undefined) + return obj + _strEmpty; + if (obj === null) + return obj + _strEmpty; + return _toStr.call(obj).replace(/^\[object (.+)\]$/, '$1').toLowerCase(); + }; + + var isFunction = function(obj) { + return type(obj) === TYPES.f; + }; + + var isArray = function(arr) { + return type(arr) === TYPES.a; + }; + + var isEmptyObject = function(obj) { + for (var name in obj ) + return false; + return true; + }; + + var isPlainObject = function(obj) { + if (!obj || type(obj) !== TYPES.o) + return false; + + var key; + var hasOwnProperty = Object.prototype.hasOwnProperty; + var hasOwnConstructor = hasOwnProperty.call(obj, 'constructor'); + var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwnProperty.call(obj.constructor.prototype, 'isPrototypeOf'); + + if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) { + return false; + } + + + for (key in obj) { /**/ } + + return typeof key === TYPES.u || hasOwnProperty.call(obj, key); + }; + + var inArray = function(item, arr) { + for (var i = 0; i < arr.length; i++) + if (arr[i] === item) + return i; + return -1; + }; + + var each = function(obj, callback) { + var i = 0; + + if (isArrayLike(obj)) { + for (; i < obj.length; i++) { + if (callback.call(obj[i], i, obj[i]) === false) + break; + } } else { - elms = document.querySelectorAll(selector); + for (i in obj) { + if (callback.call(obj[i], i, obj[i]) === false) + break; + } } - for(; i < elms.length; i++) - elments.push(elms[i]); - return new FakeJQueryInstance(elments); - } - else { - return new FakeJQueryInstance(selector); - } - }; + return obj; + }; - var extend = FakejQuery.extend = function() { - var src, copyIsArray, copy, name, options, clone, target = arguments[0] || {}, - i = 1, - length = arguments.length, - deep = false; + var FakejQuery = function (selector) { + if(arguments.length === 0) + return this; - // Handle a deep copy situation - if (typeof target === "boolean") { - deep = target; - target = arguments[1] || {}; - // skip the boolean and the target - i = 2; + var _base = new FakejQuery(); + var elements = selector; + var elms; + var el; + var i = 0; + + if(type(selector) === TYPES.s) { + elements = [ ]; + if(selector.charAt(0) === '<') { + el = document.createElement('div'); + el.innerHTML = selector; + elms = el.children; + } + else { + elms = document.querySelectorAll(selector); + } + + for(; i < elms.length; i++) + elements.push(elms[i]); + } + + if(elements) { + if(type(elements) !== TYPES.s && !elements.length) + elements = [ elements ]; + + for(i = 0; i < elements.length; i++) + _base[i] = elements[i]; + + _base.length = elements.length; + } + + return _base; + }; + + function isArrayLike(obj) { + var length = !!obj && "length" in obj && obj.length; + var t = type(obj); + + return isFunction(t) ? false : (t === TYPES.a || length === 0 || typeof length === TYPES.n && length > 0 && (length - 1) in obj); } - // Handle case when target is a string or something (possible in deep copy) - if (typeof target !== TYPES.o && !FakejQuery.type(target) === TYPES.f) { - target = {}; + function stripAndCollapse(value) { + var tokens = value.match(_rnothtmlwhite) || []; + return tokens.join(_strSpace); } - // extend jQuery itself if only one argument is passed - if (length === i) { - target = FakejQuery; - --i; + function matches(elem, selector) { + var nodeList = (elem.parentNode || document).querySelectorAll(selector) || []; + var i = nodeList.length; + + while (i--) + if (nodeList[i] == elem) + return true; + + return false; } - for (; i < length; i++) { - // Only deal with non-null/undefined values - if ((options = arguments[i]) != null) { - // Extend the base object - for (name in options) { - src = target[name]; - copy = options[name]; + function insertAdjacentElement(el, strategy, child) { + if(type(child) === TYPES.s) + el.insertAdjacentHTML(strategy, child); + else if(child.nodeType) + el.insertAdjacentElement(strategy, child); + else + el.insertAdjacentElement(strategy, child[0]); + } - // Prevent never-ending loop - if (target === copy) { - continue; + function setCSSVal(el, prop, val) { + try { + if(el.style[prop] !== undefined) + el.style[prop] = parseCSSVal(prop, val); + } catch(e) { } + } + + function parseCSSVal(prop, val) { + if(!_cssNumber[prop.toLowerCase()] && type(val) === TYPES.n) + val = val += 'px'; + return val; + } + + function startNextAnimationInQ(animObj, removeFromQ) { + var index; + var nextAnim; + if(removeFromQ !== false) + animObj.q.splice(0, 1); + if(animObj.q.length > 0) { + nextAnim = animObj.q[0]; + animate(animObj.el, nextAnim.props, nextAnim.duration, nextAnim.easing, nextAnim.complete, true); + } + else { + index = inArray(animObj, _animations); + if(index > -1) + _animations.splice(index, 1); + } + } + + function setAnimationValue(el, prop, value) { + if(prop === 'scrollLeft') + el[prop] = value; + else if(prop === 'scrollTop') + el[prop] = value; + else + setCSSVal(el, prop, value); + } + + function animate(el, props, options, easing, complete, guaranteedNext) { + var from = { }; + var to = { }; + var key; + var animObj; + var i = 0; + var start; + var progress; + var step; + var specialEasing; + var duration; + var hasOptions = isPlainObject(options); + if(hasOptions) { + easing = options.easing; + start = options.start; + progress = options.progress; + step = options.step; + specialEasing = options.specialEasing; + complete = options.complete; + duration = options.duration; + } + else + duration = options; + specialEasing = specialEasing || { }; + duration = duration || 400; + easing = easing || 'swing'; + guaranteedNext = guaranteedNext || false; + + for(; i < _animations.length; i++) { + if(_animations[i].el === el) { + animObj = _animations[i]; + break; + } + } + + if(!animObj) { + animObj = { + el : el, + q : [], + }; + _animations.push(animObj); + } + + for (key in props) { + if(key === 'scrollLeft' || key === 'scrollTop') + from[key] = el[key]; + else + from[key] = new FakejQuery(el).css(key); + } + + for (key in from) + if(from[key] !== props[key]) + to[key] = props[key]; + + if(!isEmptyObject(to)) { + var timeNow; + var end; + var percent; + var fromVal; + var toVal; + var easedVal; + var timeStart; + var frame; + var elapsed; + var qPos = guaranteedNext ? 0 : inArray(qObj, animObj.q); + var qObj = { + props : to, + duration : hasOptions ? options : duration, + easing : easing, + complete : complete, + }; + if (qPos === -1) { + qPos = animObj.q.length; + animObj.q.push(qObj); + } + + if(qPos === 0) { + if(duration > 0) { + timeStart = compatibility.now(); + frame = function() { + timeNow = compatibility.now(); + elapsed = (timeNow - timeStart); + end = qObj.stop || elapsed >= duration; + percent = 1 - ((Math.max(0, timeStart + duration - timeNow) / duration) || 0); + + for(key in to) { + fromVal = from[key]; + toVal = to[key]; + easedVal = (toVal - fromVal) * _easings[specialEasing[key] || easing](percent, percent * duration, 0, 1, duration) + fromVal; + setAnimationValue(el, key, easedVal); + if(isFunction(step)) { + step(easedVal, { + elem : el, + prop : key, + start : fromVal, + now : easedVal, + end : toVal, + pos : percent, + options : { + easing : easing, + speacialEasing : specialEasing, + duration : duration, + complete : complete, + step : step + }, + startTime : timeStart + }); + } + } + + if(isFunction(progress)) + progress({ }, percent, Math.max(0, duration - elapsed)); + + if (end) { + startNextAnimationInQ(animObj); + if(isFunction(complete)) + complete(); + } + else + qObj.frame = compatibility.rAF()(frame); + }; + qObj.frame = compatibility.rAF()(frame); } - - // Recurse if we're merging plain objects or arrays - if (deep && copy && (FakejQuery.isPlainObject(copy) || (copyIsArray = FakejQuery.isArray(copy)))) { - if (copyIsArray) { - copyIsArray = false; - clone = src && FakejQuery.isArray(src) ? src : []; - - } else { - clone = src && FakejQuery.isPlainObject(src) ? src : {}; - } - - // Never move original objects, clone them - target[name] = FakejQuery.extend(deep, clone, copy); - - // Don't bring in undefined values - } else if (copy !== undefined) { - target[name] = copy; + else { + for(key in to) + setAnimationValue(el, key, to[key]); + startNextAnimationInQ(animObj); } } } + else if(guaranteedNext) + startNextAnimationInQ(animObj); + } + + function stop(el, clearQ, jumpToEnd) { + var animObj; + var qObj; + var key; + var i = 0; + for(; i < _animations.length; i++) { + animObj = _animations[i]; + if(animObj.el === el) { + if(animObj.q.length > 0) { + qObj = animObj.q[0]; + qObj.stop = true; + compatibility.cAF()(qObj.frame); + animObj.q.splice(0, 1); + + if(jumpToEnd) + for(key in qObj.props) + setAnimationValue(el, key, qObj.props[key]); + + if(clearQ) + animObj.q = [ ]; + else + startNextAnimationInQ(animObj, false); + } + break; + } + } } - // Return the modified object - return target; - }; + FakejQuery.prototype = { + each : function(callback) { + return each(this, callback); + }, - var type = FakejQuery.type = function(obj) { - if (obj === undefined) - return obj + _strEmpty; - if (obj === null) - return obj + _strEmpty; - return _toStr.call(obj).replace(/^\[object (.+)\]$/, '$1').toLowerCase(); - }; + append : function(child) { + return this.each(function() { insertAdjacentElement(this, 'beforeend', child); }); + }, - var isFunction = FakejQuery.isFunction = function(obj) { - return type(obj) === TYPES.f; - }; + prepend : function(child) { + return this.each(function() { insertAdjacentElement(this, 'afterbegin', child); }); + }, - var isArray = FakejQuery.isArray = function(arr) { - return type(arr) === TYPES.a; - }; + before : function(child) { + return this.each(function() { insertAdjacentElement(this, 'beforebegin', child); }); + }, - var isEmptyObject = FakejQuery.isEmptyObject = function(obj) { - for (var name in obj ) - return false; - return true; - }; + after : function(child) { + return this.each(function() { insertAdjacentElement(this, 'afterend', child); }); + }, - var isPlainObject = FakejQuery.isPlainObject = function(obj) { - if (!obj || type(obj) !== TYPES.o) - return false; + hover: function(over, out) { + return this.on('mouseenter', over).on('mouseleave', out || over); + }, - var key; - var hasOwnProperty = Object.prototype.hasOwnProperty; - var hasOwnConstructor = hasOwnProperty.call(obj, 'constructor'); - var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwnProperty.call(obj.constructor.prototype, 'isPrototypeOf'); + first : function() { + return new FakejQuery(this[0]); + }, - if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) { - return false; - } + last : function() { + return new FakejQuery(this[this.length - 1]); + }, + find : function(selector) { + var children = [ ]; + var i; + this.each(function() { + var el = this; + var ch = el.querySelectorAll(selector); + for(i = 0; i < ch.length; i++) + children.push(ch[i]); + }); + return new FakejQuery(children); + }, - for (key in obj) { /**/ } + hide : function() { + return this.each(function() { this.style.display = 'none'; }); + }, - return typeof key === TYPES.u || hasOwnProperty.call(obj, key); - }; + show : function() { + return this.each(function() { this.style.display = 'block'; }); + }, - var inArray = FakejQuery.inArray = function(item, arr) { - for (var i = 0; i < arr.length; i++) - if (arr[i] === item) - return i; - return -1; - }; + attr : function(attrName, value) { + for(var i = 0; i < this.length; i++) { + var el = this[i]; + if(value === undefined) + return el.getAttribute(attrName); + el.setAttribute(attrName, value); + } + return this; + }, - var each = FakejQuery.each = function(obj, callback) { - var i = 0; + removeAttr : function(attrName) { + return this.each(function() { this.removeAttribute(attrName); }); + }, - if (isArrayLike(obj)) { - for (; i < obj.length; i++) { - if (callback.call(obj[i], i, obj[i]) === false) - break; - } - } - else { - for (i in obj) { - if (callback.call(obj[i], i, obj[i]) === false) - break; - } - } + prop : function(propertyName, value) { + for(var i = 0; i < this.length; i++) { + var el = this[i]; + if(value === undefined) + return el[propertyName]; + el[propertyName] = value; + } + return this; + }, - return obj; - }; + val : function(value) { + var el = this[0]; + if(!value) + return el.value; + el.value = value; + return this; + }, - function isArrayLike(obj) { - var length = !!obj && "length" in obj && obj.length; - var t = type(obj); + scrollLeft : function(value) { + for(var i = 0; i < this.length; i++) { + var el = this[i]; + if(value === undefined) + return el.scrollLeft; + el.scrollLeft = value; + } + return this; + }, - return isFunction(t) ? false : (t === TYPES.a || length === 0 || typeof length === TYPES.n && length > 0 && (length - 1) in obj); - } + scrollTop : function(value) { + for(var i = 0; i < this.length; i++) { + var el = this[i]; + if(value === undefined) + return el.scrollTop; + el.scrollTop = value; + } + return this; + }, - function stripAndCollapse(value) { - var tokens = value.match(_rnothtmlwhite) || []; - return tokens.join(_strSpace); - } + children : function(selector) { + var children = [ ]; + var el; + var ch; + var i; - function matches(elem, selector) { - var nodeList = (elem.parentNode || document).querySelectorAll(selector) || []; - var i = nodeList.length; + this.each(function() { + el = this; + ch = el.children; - while (i--) - if (nodeList[i] == elem) - return true; - - return false; - } - - function insertAdjacentElement(el, strategy, child) { - if(FakejQuery.type(child) === TYPES.s) - el.insertAdjacentHTML(strategy, child); - else if(child.nodeType) - el.insertAdjacentElement(strategy, child); - else - el.insertAdjacentElement(strategy, child[0]); - } - - function setCSSVal(el, prop, val) { - try { - if(el.style[prop] !== undefined) - el.style[prop] = parseCSSVal(prop, val); - } catch(e) { } - } - - function parseCSSVal(prop, val) { - if(!_cssNumber[prop.toLowerCase()] && FakejQuery.type(val) === TYPES.n) - val = val += 'px'; - return val; - } - - function startNextAnimationInQ(animObj, removeFromQ) { - var index; - var nextAnim; - if(removeFromQ !== false) - animObj.q.splice(0, 1); - if(animObj.q.length > 0) { - nextAnim = animObj.q[0]; - animate(animObj.el, nextAnim.props, nextAnim.duration, nextAnim.easing, nextAnim.complete, true); - } - else { - index = FakejQuery.inArray(animObj, _animations); - if(index > -1) - _animations.splice(index, 1); - } - } - - function setAnimationValue(el, prop, value) { - if(prop === 'scrollLeft') - el[prop] = value; - else if(prop === 'scrollTop') - el[prop] = value; - else - setCSSVal(el, prop, value); - } - - function animate(el, props, options, easing, complete, guaranteedNext) { - var from = { }; - var to = { }; - var key; - var animObj; - var i = 0; - var start; - var progress; - var step; - var specialEasing; - var duration; - var hasOptions = FakejQuery.isPlainObject(options); - if(hasOptions) { - easing = options.easing; - start = options.start; - progress = options.progress; - step = options.step; - specialEasing = options.specialEasing; - complete = options.complete; - duration = options.duration; - } - else - duration = options; - specialEasing = specialEasing || { }; - duration = duration || 400; - easing = easing || 'swing'; - guaranteedNext = guaranteedNext || false; - - for(; i < _animations.length; i++) { - if(_animations[i].el === el) { - animObj = _animations[i]; - break; - } - } - - if(!animObj) { - animObj = { - el : el, - q : [], - }; - _animations.push(animObj); - } - - for (key in props) { - if(key === 'scrollLeft' || key === 'scrollTop') - from[key] = el[key]; - else - from[key] = new FakeJQueryInstance(el).css(key); - } - - for (key in from) - if(from[key] !== props[key]) - to[key] = props[key]; - - if(!FakejQuery.isEmptyObject(to)) { - var timeNow; - var end; - var percent; - var fromVal; - var toVal; - var easedVal; - var timeStart; - var frame; - var elapsed; - var qPos = guaranteedNext ? 0 : FakejQuery.inArray(qObj, animObj.q); - var qObj = { - props : to, - duration : hasOptions ? options : duration, - easing : easing, - complete : complete, - }; - if (qPos === -1) { - qPos = animObj.q.length; - animObj.q.push(qObj); - } - - if(qPos === 0) { - if(duration > 0) { - timeStart = compatibility.now(); - frame = function() { - timeNow = compatibility.now(); - elapsed = (timeNow - timeStart); - end = qObj.stop || elapsed >= duration; - percent = 1 - ((Math.max(0, timeStart + duration - timeNow) / duration) || 0); - - for(key in to) { - fromVal = from[key]; - toVal = to[key]; - easedVal = (toVal - fromVal) * _easings[specialEasing[key] || easing](percent, percent * duration, 0, 1, duration) + fromVal; - setAnimationValue(el, key, easedVal); - if(isFunction(step)) { - step(easedVal, { - elem : el, - prop : key, - start : fromVal, - now : easedVal, - end : toVal, - pos : percent, - options : { - easing : easing, - speacialEasing : specialEasing, - duration : duration, - complete : complete, - step : step - }, - startTime : timeStart - }); - } - } - - if(isFunction(progress)) - progress({ }, percent, Math.max(0, duration - elapsed)); - - if (end) { - startNextAnimationInQ(animObj); - if(isFunction(complete)) - complete(); + for(i = 0; i < ch.length; i++) { + var el = ch[i]; + if(selector) { + if((el.matches && el.matches(selector)) || matches(el, selector)) + children.push(el); } else - qObj.frame = compatibility.rAF()(frame); - }; - qObj.frame = compatibility.rAF()(frame); - } - else { - for(key in to) - setAnimationValue(el, key, to[key]); - startNextAnimationInQ(animObj); - } - } - } - else if(guaranteedNext) - startNextAnimationInQ(animObj); - } - - function stop(el, clearQ, jumpToEnd) { - var animObj; - var qObj; - var key; - var i = 0; - for(; i < _animations.length; i++) { - animObj = _animations[i]; - if(animObj.el === el) { - if(animObj.q.length > 0) { - qObj = animObj.q[0]; - qObj.stop = true; - compatibility.cAF()(qObj.frame); - animObj.q.splice(0, 1); - - if(jumpToEnd) - for(key in qObj.props) - setAnimationValue(el, key, qObj.props[key]); - - if(clearQ) - animObj.q = [ ]; - else - startNextAnimationInQ(animObj, false); - } - break; - } - } - } - - function FakeJQueryInstance(elements) { - var _base = this; - if(FakejQuery.type(elements) !== TYPES.s && !elements.length) - elements = [ elements ]; - - for(var i = 0; i < elements.length; i++) - _base[i] = elements[i]; - _base.length = elements.length; - return _base; - } - - FakeJQueryInstance.prototype = { - each : function(callback) { - return each(this, callback); - }, - - append : function(child) { - return this.each(function() { insertAdjacentElement(this, 'beforeend', child); }); - }, - - prepend : function(child) { - return this.each(function() { insertAdjacentElement(this, 'afterbegin', child); }); - }, - - before : function(child) { - return this.each(function() { insertAdjacentElement(this, 'beforebegin', child); }); - }, - - after : function(child) { - return this.each(function() { insertAdjacentElement(this, 'afterend', child); }); - }, - - hover: function(over, out) { - return this.on('mouseenter', over).on('mouseleave', out || over); - }, - - first : function() { - return new FakeJQueryInstance(this[0]); - }, - - last : function() { - return new FakeJQueryInstance(this[this.length - 1]); - }, - - find : function(selector) { - var children = [ ]; - var i; - this.each(function() { - var el = this; - var ch = el.querySelectorAll(selector); - for(i = 0; i < ch.length; i++) - children.push(ch[i]); - }); - return new FakeJQueryInstance(children); - }, - - hide : function() { - return this.each(function() { this.style.display = 'none'; }); - }, - - show : function() { - return this.each(function() { this.style.display = 'block'; }); - }, - - attr : function(attrName, value) { - for(var i = 0; i < this.length; i++) { - var el = this[i]; - if(value === undefined) - return el.getAttribute(attrName); - el.setAttribute(attrName, value); - } - return this; - }, - - removeAttr : function(attrName) { - return this.each(function() { this.removeAttribute(attrName); }); - }, - - prop : function(propertyName, value) { - for(var i = 0; i < this.length; i++) { - var el = this[i]; - if(value === undefined) - return el[propertyName]; - el[propertyName] = value; - } - return this; - }, - - val : function(value) { - var el = this[0]; - if(!value) - return el.value; - el.value = value; - return this; - }, - - scrollLeft : function(value) { - for(var i = 0; i < this.length; i++) { - var el = this[i]; - if(value === undefined) - return el.scrollLeft; - el.scrollLeft = value; - } - return this; - }, - - scrollTop : function(value) { - for(var i = 0; i < this.length; i++) { - var el = this[i]; - if(value === undefined) - return el.scrollTop; - el.scrollTop = value; - } - return this; - }, - - children : function(selector) { - var children = [ ]; - var el; - var ch; - var i; - - this.each(function() { - el = this; - ch = el.children; - - for(i = 0; i < ch.length; i++) { - var el = ch[i]; - if(selector) { - if((el.matches && el.matches(selector)) || matches(el, selector)) children.push(el); } - else - children.push(el); - } - }); - return new FakeJQueryInstance(children); - }, + }); + return new FakejQuery(children); + }, - on : function(eventName, handler) { - eventName = (eventName || _strEmpty).match(_rnothtmlwhite) || [_strEmpty]; + on : function(eventName, handler) { + eventName = (eventName || _strEmpty).match(_rnothtmlwhite) || [_strEmpty]; - var i; - var el; - return this.each(function() { - el = this; - if (el.addEventListener) { - for (i = 0; i < eventName.length; i++) - el.addEventListener(eventName[i], handler); - } - else if(el.detachEvent) { - for (i = 0; i < eventName.length; i++) - el.attachEvent('on' + eventName[i], handler); - } - }); - }, + var i; + var el; + return this.each(function() { + el = this; + if (el.addEventListener) { + for (i = 0; i < eventName.length; i++) + el.addEventListener(eventName[i], handler); + } + else if(el.detachEvent) { + for (i = 0; i < eventName.length; i++) + el.attachEvent('on' + eventName[i], handler); + } + }); + }, - off : function(eventName, handler) { - eventName = (eventName || _strEmpty).match(_rnothtmlwhite) || [_strEmpty]; + off : function(eventName, handler) { + eventName = (eventName || _strEmpty).match(_rnothtmlwhite) || [_strEmpty]; - var i; - var el; - return this.each(function() { - el = this; - if (el.removeEventListener) { - for (i = 0; i < eventName.length; i++) - el.removeEventListener(eventName[i], handler); - } - else if(el.detachEvent) { - for (i = 0; i < eventName.length; i++) - el.detachEvent('on' + eventName[i], handler); - } - }); - }, + var i; + var el; + return this.each(function() { + el = this; + if (el.removeEventListener) { + for (i = 0; i < eventName.length; i++) + el.removeEventListener(eventName[i], handler); + } + else if(el.detachEvent) { + for (i = 0; i < eventName.length; i++) + el.detachEvent('on' + eventName[i], handler); + } + }); + }, - trigger : function(eventName) { - var el; - var event; - return this.each(function() { - el = this; - if (document.createEvent) { - event = document.createEvent('HTMLEvents'); - event.initEvent(eventName, true, false); - el.dispatchEvent(event); - } - else { - el.fireEvent("on" + eventName); - } - }); - }, + trigger : function(eventName) { + var el; + var event; + return this.each(function() { + el = this; + if (document.createEvent) { + event = document.createEvent('HTMLEvents'); + event.initEvent(eventName, true, false); + el.dispatchEvent(event); + } + else { + el.fireEvent("on" + eventName); + } + }); + }, - hasClass : function(className) { - var elem, i = 0; - var classNamePrepared = _strSpace + className + _strSpace; + hasClass : function(className) { + var elem, i = 0; + var classNamePrepared = _strSpace + className + _strSpace; - while ((elem = this[ i++ ])) { - if(elem.classList) { - if(elem.classList.contains(className)) + while ((elem = this[ i++ ])) { + if(elem.classList) { + if(elem.classList.contains(className)) + return true; + } + else if (elem.nodeType === 1 && (_strSpace + stripAndCollapse(elem.className) + _strSpace).indexOf(classNamePrepared) > -1 ) return true; } - else if (elem.nodeType === 1 && (_strSpace + stripAndCollapse(elem.className) + _strSpace).indexOf(classNamePrepared) > -1 ) - return true; - } - return false; - }, + return false; + }, - addClass : function(className) { - var classes; - var elem; - var cur; - var curValue; - var clazz; - var finalValue; - var supportClassList = null; - var i = 0; - var v = 0; + addClass : function(className) { + var classes; + var elem; + var cur; + var curValue; + var clazz; + var finalValue; + var supportClassList = null; + var i = 0; + var v = 0; - if (className) { - classes = className.match( _rnothtmlwhite ) || []; + if (className) { + classes = className.match( _rnothtmlwhite ) || []; - while ((elem = this[i++])) { - if(supportClassList === undefined) - supportClassList = elem.classList !== undefined; + while ((elem = this[i++])) { + if(supportClassList === undefined) + supportClassList = elem.classList !== undefined; - if(supportClassList) { - while ((clazz = classes[v++])) - elem.classList.add(clazz); - } - else { - curValue = elem.className; - cur = elem.nodeType === 1 && (_strSpace + stripAndCollapse(curValue) + _strSpace); - - if (cur) { + if(supportClassList) { while ((clazz = classes[v++])) - if (cur.indexOf(_strSpace + clazz + _strSpace) < 0) - cur += clazz + _strSpace; + elem.classList.add(clazz); + } + else { + curValue = elem.className; + cur = elem.nodeType === 1 && (_strSpace + stripAndCollapse(curValue) + _strSpace); - finalValue = stripAndCollapse(cur); - if (curValue !== finalValue) - elem.className = finalValue; + if (cur) { + while ((clazz = classes[v++])) + if (cur.indexOf(_strSpace + clazz + _strSpace) < 0) + cur += clazz + _strSpace; + + finalValue = stripAndCollapse(cur); + if (curValue !== finalValue) + elem.className = finalValue; + } } } } - } - return this; - }, + return this; + }, - removeClass : function(className) { - var classes; - var elem; - var cur; - var curValue; - var clazz; - var finalValue; - var supportClassList = null; - var i = 0; - var v = 0; + removeClass : function(className) { + var classes; + var elem; + var cur; + var curValue; + var clazz; + var finalValue; + var supportClassList = null; + var i = 0; + var v = 0; - if (className) { - classes = className.match(_rnothtmlwhite) || []; + if (className) { + classes = className.match(_rnothtmlwhite) || []; - while ((elem = this[i++])) { - if(supportClassList === undefined) - supportClassList = elem.classList !== undefined; + while ((elem = this[i++])) { + if(supportClassList === undefined) + supportClassList = elem.classList !== undefined; - if(supportClassList) { - while ((clazz = classes[v++])) - elem.classList.remove(clazz); - } - else { - curValue = elem.className; - cur = elem.nodeType === 1 && (_strSpace + stripAndCollapse(curValue) + _strSpace); - - if (cur) { + if(supportClassList) { while ((clazz = classes[v++])) - while (cur.indexOf(_strSpace + clazz + _strSpace) > -1) - cur = cur.replace(_strSpace + clazz + _strSpace, _strSpace); + elem.classList.remove(clazz); + } + else { + curValue = elem.className; + cur = elem.nodeType === 1 && (_strSpace + stripAndCollapse(curValue) + _strSpace); - finalValue = stripAndCollapse(cur); - if (curValue !== finalValue) - elem.className = finalValue; + if (cur) { + while ((clazz = classes[v++])) + while (cur.indexOf(_strSpace + clazz + _strSpace) > -1) + cur = cur.replace(_strSpace + clazz + _strSpace, _strSpace); + + finalValue = stripAndCollapse(cur); + if (curValue !== finalValue) + elem.className = finalValue; + } } } } - } - return this; - }, + return this; + }, - remove : function() { - return this.each(function() { - var el = this; - if(el.parentNode != null) - el.parentNode.removeChild(el); - }); - }, + remove : function() { + return this.each(function() { + var el = this; + if(el.parentNode != null) + el.parentNode.removeChild(el); + }); + }, - offset : function() { - var el = this[0]; - var rect = el.getBoundingClientRect(); - var scrollLeft = window.pageXOffset || document.documentElement.scrollLeft; - var scrollTop = window.pageYOffset || document.documentElement.scrollTop; - return { - top: rect.top + scrollTop, - left: rect.left + scrollLeft - }; - }, + offset : function() { + var el = this[0]; + var rect = el.getBoundingClientRect(); + var scrollLeft = window.pageXOffset || document.documentElement.scrollLeft; + var scrollTop = window.pageYOffset || document.documentElement.scrollTop; + return { + top: rect.top + scrollTop, + left: rect.left + scrollLeft + }; + }, - css : function(styles, val) { - var el; - var key; + position : function() { + var el = this[0]; + return { + top: el.offsetTop, + left: el.offsetLeft + }; + }, - if(FakejQuery.type(styles) === TYPES.s) { - if(val === undefined) { - el = this[0]; - return window.getComputedStyle ? window.getComputedStyle(el, null).getPropertyValue(styles) : el.currentStyle[styles]; + css : function(styles, val) { + var el; + var key; + + if(type(styles) === TYPES.s) { + if(val === undefined) { + el = this[0]; + return window.getComputedStyle ? window.getComputedStyle(el, null).getPropertyValue(styles) : el.currentStyle[styles]; + } + else { + return this.each(function() { + setCSSVal(this, styles, val); + }); + } } else { return this.each(function() { - setCSSVal(this, styles, val); + for(key in styles) + setCSSVal(this, key, styles[key]); }); } - } - else { + }, + + unwrap : function() { + var parents = [ ]; + var i; + var el; + var parent; + + this.each(function() { + parent = this.parentNode; + if(inArray(parent, parents) === - 1) + parents.push(parent); + }); + + for(i = 0; i < parents.length; i++) { + el = parents[i]; + parent = el.parentNode; + while (el.firstChild) + parent.insertBefore(el.firstChild, el); + parent.removeChild(el); + } + + return this; + }, + + wrapAll : function(wrapperHTML) { + var i; + var nodes = this; + var wrapper = new FakejQuery(wrapperHTML)[0]; + var deepest = wrapper; + var parent = nodes[0].parentNode; + var previousSibling = nodes[0].previousSibling; + while(deepest.childNodes.length > 0) + deepest = deepest.childNodes[0]; + + for (i = 0; nodes.length - i; deepest.firstChild === nodes[0] && i++) + deepest.appendChild(nodes[i]); + + var nextSibling = previousSibling ? previousSibling.nextSibling : parent.firstChild; + parent.insertBefore(wrapper, nextSibling); + + return this; + }, + + wrapInner : function(wrapperHTML) { return this.each(function() { - for(key in styles) - setCSSVal(this, key, styles[key]); - }); - } - }, + var el = new FakejQuery(this); + var contents = el.contents(); - unwrap : function() { - var parents = [ ]; - var i; - var el; - var parent; - - this.each(function() { - parent = this.parentNode; - if(FakejQuery.inArray(parent, parents) === - 1) - parents.push(parent); - }); - - for(i = 0; i < parents.length; i++) { - el = parents[i]; - parent = el.parentNode; - while (el.firstChild) - parent.insertBefore(el.firstChild, el); - parent.removeChild(el); - } - - return this; - }, - - wrapAll : function(wrapperHTML) { - var i; - var nodes = this; - var wrapper = new FakejQuery(wrapperHTML)[0]; - var deepest = wrapper; - var parent = nodes[0].parentNode; - var previousSibling = nodes[0].previousSibling; - while(deepest.childNodes.length > 0) - deepest = deepest.childNodes[0]; - - for (i = 0; nodes.length - i; deepest.firstChild === nodes[0] && i++) - deepest.appendChild(nodes[i]); - - var nextSibling = previousSibling ? previousSibling.nextSibling : parent.firstChild; - parent.insertBefore(wrapper, nextSibling); - - return this; - }, - - wrapInner : function(wrapperHTML) { - return this.each(function() { - var el = new FakeJQueryInstance(this); - var contents = el.contents(); - - if (contents.length) - contents.wrapAll(wrapperHTML); - else - el.append(wrapperHTML); - }); - }, - - wrap : function(wrapperHTML) { - return this.each(function() { new FakejQuery(this).wrapAll(wrapperHTML); }); - }, - - contents : function() { - var contents = [ ]; - var childs; - var i; - - this.each(function() { - childs = this.childNodes; - for(i = 0; i < childs.length; i++) - contents.push(childs[i]); - }); - - return new FakeJQueryInstance(contents); - }, - - parent : function() { - var parents = [ ]; - this.each(function() { parents.push(this.parentNode); }); - return new FakeJQueryInstance(parents); - }, - - is : function(selector) { - var el; - var i; - for(i = 0; i < this.length; i++) { - el = this[i]; - if(selector === ":visible") - return el.style.display !== 'none'; - if(selector === ":hidden") - return el.style.display === 'none'; - if((el.matches && el.matches(selector)) || matches(el, selector)) - return true; - } - return false; - }, - - animate : function(props, duration, easing, complete) { - return this.each(function() { animate(this, props, duration, easing, complete); }); - }, - - stop : function(clearQ, jump) { - return this.each(function() { stop(this, clearQ, jump); }); - } - }; - - return FakejQuery; - })(COMPATIBILITY); - var INSTANCES = (function(helper) { - var _targets = [ ]; - var _instancePropertyString = '__overlayScrollbars__'; - - /** - * Registers the given instance to the given element. - * @param target The target element. - * @param instance The instance. - */ - function registerInstanceToTarget(target, instance) { - target[_instancePropertyString] = instance; - _targets.push(target); - } - - /** - * Unregisters the instance from the given element. - * @param target The target element. - */ - function unregisterInstanceFromTarget(target) { - var index = helper.inArray(target, _targets); - if (index > -1) { - delete target[_instancePropertyString]; - _targets.splice(index, 1); - } - } - - /** - * Checks if the target element has a registered instance. - * @param target The target element. - * @returns {boolean} True if the target element is already registered, false otherwise. - */ - function targetHasRegisteredInstance(target) { - return getRegisteredInstanceFromTarget(target) !== undefined; - } - - /** - * Gets the registered instance of the given element. - * @param target The target element. - * @returns {*} The registered instance of the target or undefined if there isn't any. - */ - function getRegisteredInstanceFromTarget(target) { - for(var i = 0; i < _targets.length; i++) - if(target === _targets[i]) - return target[_instancePropertyString]; - - } - - return { - all : function() { - return _targets; - }, - add : registerInstanceToTarget, - rem : unregisterInstanceFromTarget, - has : targetHasRegisteredInstance, - get : getRegisteredInstanceFromTarget - }; - })(HELPER); - var BYPROPERTYPATH = (function(helper) { - /** - * Super 1337 recursive method which i don't want to document entirely. - * @param object The object. - * @param propertyString The PropertyString. - * @param propertyStringProgress The PropertyStringProgress (generated automatically because of recursion, if you call this method manually, pass undefined or a empty string!) - * @param callbackOnProperty Callback which gets called if the property was found. - * @param callbackOnParentObject - * @returns {boolean|string} True if property found, false or string otherwise. A string indicates where the property path couldn't be resolved anymore. - */ - function _getPropertyByStringMaster(object, propertyString, propertyStringProgress, callbackOnProperty, callbackOnParentObject) { - var found = false; - - propertyStringProgress = propertyStringProgress === undefined ? '' : propertyStringProgress; - - if (typeof propertyString !== TYPES.s) - return found; - if (propertyString.length === 0) - return found; - - if (propertyStringProgress === '') { - var nameSplit = propertyString.split('.'); - var currObj = object; - var nameProgression = ''; - var pathIsInvalid = false; - - for (var i = 0; i < nameSplit.length; i++) { - var currSplit = nameSplit[i]; - currObj = currObj[currSplit]; - nameProgression += currSplit + '.'; - if (helper.type(currObj) !== TYPES.o && i + 1 !== nameSplit.length) { - pathIsInvalid = true; - break; - } - } - if (pathIsInvalid) - return nameProgression.slice(0, -1); - } - - for (var prop in object) { - if (object.hasOwnProperty(prop)) { - var isSearchedProperty = (propertyStringProgress + prop) === propertyString; - if (helper.type(object[prop]) === TYPES.o && !isSearchedProperty) { - found = _getPropertyByStringMaster(object[prop], propertyString, propertyStringProgress + prop + '.', callbackOnProperty, callbackOnParentObject); - if (typeof callbackOnParentObject === TYPES.f) - callbackOnParentObject(object, prop); - if (found) - break; - } - else if (isSearchedProperty) { - if (typeof callbackOnProperty === TYPES.f) - callbackOnProperty(object, prop); - found = true; - break; - } - } - } - - return found; - } - - return { - /** - * Indicates whether the given object has the given property path. - * @param object {object} The object to which the property path shall be applied. - * @param propertyPath {string} The property path which shall be checked. - * @returns {boolean} True if the object has the given property path, false otherwise. - */ - has : function(object, propertyPath) { - return _getPropertyByStringMaster(object, propertyPath); - }, - - /** - * Gets the value of the property which is represented by the property path. - * @param object {object} The object to which the property path shall be applied. - * @param propertyPath {string} The property path which leads to the property which shall be get. - * @returns {object|undefined} The property value of the property to which the given property path led. Undefined if the property path led to a non existent property. - */ - get : function(object, propertyPath) { - var result; - _getPropertyByStringMaster(object, propertyPath, '', function (obj, prop) { - result = obj[prop]; - }); - return result; - }, - - /** - * Changes the value of the property which is represented by the property path. - * If the property to which the property path leads does not exist, then nothing happens. - * @param object {object} The object to which the property path shall be applied. - * @param propertyPath {string} The property path which leads to the property which shall be set. - * @param propertyValue {object} The value of the property to which the property path leads. - * @param create {boolean} Indicates whether the property shall be created if it is not existent. With this parameter set to true the return value will be also always true. - * @returns {boolean} True if the property was found and the value was successfully changed, false otherwise. - */ - set : function setPropertyByString(object, propertyPath, propertyValue, create) { - var result = false; - _getPropertyByStringMaster(object, propertyPath, '', function (obj, prop) { - obj[prop] = propertyValue; - result = true; - }); - if (!result && create) { - var propertyPathSplits = propertyPath.split('.'); - var obj = {}; - var tmp = obj; - for (var i = 0; i < propertyPathSplits.length; i++) { - var value = i === propertyPathSplits.length - 1 ? propertyValue : { }; - tmp = tmp[propertyPathSplits[i]] = value; - } - helper.extend(true, object, obj); - result = true; - } - return result; - }, - - /** - * Deletes the property which is represented by the property path. - * @param object {object} The object to which the property path shall be applied. - * @param propertyPath {string} The property path which leads to the property which shall be deleted. - * @param deleteParentObjectIfEmpty {boolean} True if the parent object of the property which shall be deleted, shall be deleted too if it is empty after the deletion of the property. - * @returns {boolean} True if the property to which the property path shall lead, was found and deleted, false otherwise. - */ - del : function delPropertyByString(object, propertyPath, deleteParentObjectIfEmpty) { - var result = false; - _getPropertyByStringMaster(object, propertyPath, '', function (obj, prop) { - delete obj[prop]; - result = true; - }, function (obj, prop) { - if (deleteParentObjectIfEmpty) { - if (helper.isEmptyObject(obj[prop])) { - delete obj[prop]; - } - } - }); - return result; - } - }; - })(HELPER); - var PLUGIN = (function(compatibility, instances, helper, byPropertyPath) { - var _pluginGlobals; - var _pluginAutoUpdateLoop; - var _pluginDefaultOptions = { - className : 'os-theme-dark', //null || string - resize : 'none', //none || both || horizontal || vertical || n || b || h || v - sizeAutoCapable : true, //true || false - clipAlways : true, //true || false - normalizeRTL : true, //true || false - paddingAbsolute : false, //true || false - autoUpdate : null, //true || false || null - autoUpdateInterval : 33, //number - nativeScrollbarsOverlaid : { - showNativeScrollbars : false, //true || false - initialize : true //true || false - }, - overflowBehavior : { - x : 'scroll', //visible-hidden || visible-scroll || hidden || scroll || v-h || v-s || h || s - y : 'scroll' //visible-hidden || visible-scroll || hidden || scroll || v-h || v-s || h || s - }, - scrollbars : { - visibility : 'auto', //visible || hidden || auto || v || h || a - autoHide : 'never', //never || scroll || leave || move || n || s || l || m - autoHideDelay : 800, //number - dragScrolling : true, //true || false - clickScrolling : false, //true || false - touchSupport : true //true || false - }, - textarea : { - dynWidth : false, //true || false - dynHeight : false //true || false - }, - callbacks : { - onInitialized : null, //null || function - onInitializationWithdrawn : null, //null || function - onDestroyed : null, //null || function - onScrollStart : null, //null || function - onScroll : null, //null || function - onScrollStop: null, //null || function - onOverflowChanged : null, //null || function - onOverflowAmountChanged : null, //null || function - onDirectionChanged : null, //null || function - onContentSizeChanged : null, //null || function - onHostSizeChanged : null, //null || function - onUpdated : null //null || function - } - }; - - /** - * Initializes the object which contains global information about the plugin and each instance of it. - */ - function initOverlayScrollbarsStatics() { - if(_pluginGlobals === undefined) - _pluginGlobals = new OverlayScrollbarsGlobals(_pluginDefaultOptions); - if(_pluginAutoUpdateLoop === undefined) - _pluginAutoUpdateLoop = new OverlayScrollbarsAutoUpdateLoop(_pluginGlobals); - } - - /** - * The global object for the hide scrollbars objects. It contains resources which every hide scrollbars object needs. This object is initialized only once: if the first hide scrollbars object gets initialized. - * @param defaultOptions - * @constructor - */ - function OverlayScrollbarsGlobals(defaultOptions) { - var _base = this; - _base.defaultOptions = defaultOptions; - _base.autoUpdateLoop = false; - _base.autoUpdateRecommended = compatibility.mO() === undefined; - var bodyElement = helper('body'); - var scrollbarDummyElement = helper('
'); - var nativeScrollbarSize = (function() { - bodyElement.append(scrollbarDummyElement); - var strOverflow = 'overflow'; - var strHidden = 'hidden'; - var scrollbarDummyElement0 = scrollbarDummyElement[0]; - var dummyContainerChild = helper(scrollbarDummyElement.children('div').first()); - var IEBUGFIX = scrollbarDummyElement0[WORDING.oH]; //IE9 causes a bug where offsetHeight is zero for no reason - var scrollbarSize; - if(IEBUGFIX === 0) - scrollbarDummyElement.hide().show(); - scrollbarSize = { - x: scrollbarDummyElement0[WORDING.oH] - scrollbarDummyElement0[WORDING.cH], - y: scrollbarDummyElement0[WORDING.oW] - scrollbarDummyElement0[WORDING.cW] - }; - //https://bugzilla.mozilla.org/show_bug.cgi?id=1439305 - _base.restrictedMeasuring = (function() { - scrollbarDummyElement.css(strOverflow, strHidden); - var scrollSize = { - w : scrollbarDummyElement0[WORDING.sW], - h : scrollbarDummyElement0[WORDING.sH] - }; - scrollbarDummyElement.css(strOverflow, 'visible'); - var scrollSize2 = { - w : scrollbarDummyElement0[WORDING.sW], - h : scrollbarDummyElement0[WORDING.sH] - }; - return (scrollSize.w - scrollSize2.w) !== 0 || (scrollSize.h - scrollSize2.h) !== 0; - })(); - _base.nativeScrollbarStyling = (function() { - scrollbarDummyElement.addClass('os-viewport-native-scrollbars-invisible'); - scrollbarDummyElement.css(strOverflow, strHidden).hide().css(strOverflow, 'scroll').show(); //fix opera bug: scrollbar styles will only appear if overflow value is scroll or auto during the activation of the style. - return (scrollbarDummyElement0[WORDING.oH] - scrollbarDummyElement0[WORDING.cH]) === 0 && (scrollbarDummyElement0[WORDING.oW] - scrollbarDummyElement0[WORDING.cW]) === 0; - })(); - _base.rtlScrollBehavior = (function() { - scrollbarDummyElement.css({ 'overflow-y' : strHidden, '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 - }; - })(); - scrollbarDummyElement.removeAttr(WORDING.s).remove(); - return scrollbarSize; - })(); - var nativeScrollbarIsOverlaid = { - x: nativeScrollbarSize.x === 0, - y: nativeScrollbarSize.y === 0 - }; - _base.nativeScrollbarSize = nativeScrollbarSize; - _base.nativeScrollbarIsOverlaid = nativeScrollbarIsOverlaid; - _base.overlayScrollbarDummySize = { - x: 30, - y: 30 - }; - _base.msie = (function() { - var ua = window.navigator.userAgent; - - var msie = ua.indexOf('MSIE '); - if (msie > 0) { - // IE 10 or older => return version number - return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10); - } - - var trident = ua.indexOf('Trident/'); - if (trident > 0) { - // IE 11 => return version number - var rv = ua.indexOf('rv:'); - return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10); - } - - var edge = ua.indexOf('Edge/'); - if (edge > 0) { - // Edge (IE 12+) => return version number - return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10); - } - - // other browser - return false; - })(); - _base.cssCalc = (function() { - var dummy = document.createElement('div'); - var props = ['calc', '-webkit-calc', '-moz-calc', '-o-calc']; - for (var i = 0; i < props.length; ++i) { - var prop = props[i]; - dummy.style.cssText = 'width:' + prop + '(1px);'; - if (dummy.style.length) - return prop; - } - return null; - })(); - function detectCSSFeature(featurename) { - var feature = false, - domPrefixes = 'Webkit Moz ms O'.split(' '), - elm = document.createElement('div'), - featurenameCapital = null; - - featurename = featurename.toLowerCase(); - - if (elm.style[featurename] !== undefined) { - feature = true; - } - - if (feature === false) { - featurenameCapital = featurename.charAt(0).toUpperCase() + featurename.substr(1); - for (var i = 0; i < domPrefixes.length; i++) { - if (elm.style[domPrefixes[i] + featurenameCapital] !== undefined) { - feature = true; - break; - } - } - } - return feature; - } - _base.supportTransform = detectCSSFeature("transform"); - _base.supportTransition = detectCSSFeature("transition"); - //passive event support - var supportsPassive = false; - try { - var opts = Object.defineProperty({}, 'passive', { - get: function() { - supportsPassive = true; - } - }); - window.addEventListener('test', null, opts); - } catch (e) { } - _base.supportPassiveEvents = supportsPassive; - _base.supportResizeObserver = compatibility.rO() !== undefined; - _base.supportMutationObserver = compatibility.mO() !== undefined; - - //Catch zoom event: - (function () { - if(nativeScrollbarIsOverlaid.x && nativeScrollbarIsOverlaid.y) - return; - - var windowWidth = compatibility.wW(); - var windowHeight = compatibility.wH(); - var windowDpr = getWindowDPR(); - - function differenceIsBiggerThanOne(valOne, valTwo) { - var absValOne = Math.abs(valOne); - var absValTwo = Math.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); - } - - helper(window).on('resize', function() { - if(instances.all().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 = Math.abs(deltaW); - var absDeltaH = Math.abs(deltaH); - var absDeltaWRatio = Math.abs(deltaWRatio); - var absDeltaHRatio = Math.abs(deltaHRatio); - var newDPR = getWindowDPR(); - - var deltaIsBigger = absDeltaW > 2 && absDeltaH > 2; - var difference = !differenceIsBiggerThanOne(absDeltaWRatio, absDeltaHRatio); - var dprChanged = newDPR !== windowDpr && windowDpr > 0; - var windowResized = !(deltaIsBigger && difference && dprChanged); - - if (!windowResized) { - bodyElement.append(scrollbarDummyElement); - var measure = scrollbarDummyElement[0]; - _base.nativeScrollbarSize = { - x: measure[WORDING.oH] - measure[WORDING.cH], - y: measure[WORDING.oW] - measure[WORDING.cW] - }; - scrollbarDummyElement.remove(); - helper.each(instances.all(), function () { - if(instances.has(this)) - instances.get(this).update('zoom'); - }); - } - - windowWidth = newW; - windowHeight = newH; - windowDpr = newDPR; - } - }); - })(); - } - - /** - * The object which manages the auto update loop for all hide scrollbars objects. This object is initialized only once: if the first hide scrollbars object gets initialized. - * @constructor - */ - function OverlayScrollbarsAutoUpdateLoop(globals) { - var _base = this; - var _strAutoUpdate = 'autoUpdate'; - var _strAutoUpdateInterval = _strAutoUpdate + 'Interval'; - - 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.length > 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.length; 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(helper.inArray(instance, _loopingInstances) === -1) { - _loopingInstances.push(instance); - _loopingInstancesIntervalCache.push(compatibility.now()); - if (_loopingInstances.length > 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 = helper.inArray(instance, _loopingInstances); - if(index > -1) { - //remove from loopingInstances list - _loopingInstancesIntervalCache.splice(index, 1); - _loopingInstances.splice(index, 1); - - //correct update loop behavior - if (_loopingInstances.length === 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 globals - * @param autoUpdateLoop - * @returns {*} - * @constructor - */ - function OverlayScrollbarsInstance(pluginTargetElement, options, 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.has(pluginTargetElement)) { - var inst = instances.get(pluginTargetElement); - inst.options(options); - return inst; - } - - //make correct instanceof - var _base = new window[PLUGINNAME](); - - //general: - var _initialized = false; - var _destroyed = false; - var _isTextarea = false; - var _isBody = false; - var _sizeAutoObserverAdded = false; - var _contentBorderSize = { w: 0, h: 0 }; - var _scrollHorizontalInfo = { }; - var _scrollVerticalInfo = { }; - var _viewportSize = { }; - var _rtlScrollBehavior; - var _autoUpdateRecommended; - var _msieVersion; - var _nativeScrollbarStyling; - var _cssCalc; - var _nativeScrollbarSize; - var _nativeScrollbarMinSize; - var _nativeScrollbarIsOverlaid; - var _overlayScrollbarDummySize; - var _supportTransition; - var _supportTransform; - var _supportPassiveEvents; - var _supportResizeObserver; - var _restrictedMeasuring; - var _isBorderBox; - var _paddingX; - var _paddingY; - var _borderX; - var _borderY; - var _marginX; - var _marginY; - var _isRTL; - var _isSleeping; - - //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 _strDivBegin = "
"; - 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'; - 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; - - //update - var _lastUpdateTime; - var _swallowedUpdateParams = { }; - var _swallowedUpdateTimeout; - var _swallowUpdateLag = 33; - var _imgs = [ ]; - - //DOM elements: - var _windowElement; - var _documentElement; - var _htmlElement; - var _bodyElement; - var _targetElement; //the target element of this hide scrollbars object - var _hostElement; //the host element of this hide scrollbars 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; - - //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 = { - x: 0, - y: 0 - }; - var _resizeDragStartSize = { - w: 0, - h: 0 - }; - - /** - * 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 onHostResized() { - if (_isSleeping) - return; - var measureElement = _sizeObserverElement[0]; - var hostSize = { - w: measureElement[WORDING.sW], - h: measureElement[WORDING.sH] - }; - if (_initialized) { - var changed = checkCacheDouble(hostSize, _hostElementSizeChangeDetectedCache); - _hostElementSizeChangeDetectedCache = hostSize; - if (changed) - update(true, false); - } - else { - _hostElementSizeChangeDetectedCache = hostSize; - } - } - - /** - * 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); - } - - /** - * 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).first(); - 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).first().css(css); - } - */ - } - } - - /** - * 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 callback = function (e) { - targetElement.scrollTop(constMaximum); - targetElement.scrollLeft(_isRTL ? _rtlScrollBehavior.n ? -constMaximum : _rtlScrollBehavior.i ? 0 : constMaximum : constMaximum); - onElementResizedCallback(); - }; - if (_supportResizeObserver) { - var resizeObserver = compatibility.rO(); - var element = targetElement.append(_strDivBegin + _classNameResizeObserverElement + ' observed' + _strDivEnd).contents()[0]; - var observer = element[_strResizeObserverProperty] = new resizeObserver(callback); - observer.observe(element); - } - else { - var strAnimationStartEvent = 'animationstart mozAnimationStart webkitAnimationStart MSAnimationStart'; - if (_msieVersion > 9 || !_autoUpdateRecommended) { - var strDivClose = '">'; - var strDivEnd = ""; - var strChildNodes = 'childNodes'; - var observerDOM = _strDivBegin + _classNameResizeObserverElement + strDivClose; - observerDOM += _strDivBegin + _classNameResizeObserverItemElement + '" dir="ltr' + strDivClose; - observerDOM += _strDivBegin + _classNameResizeObserverItemElement + strDivClose; - observerDOM += _strDivBegin + _classNameResizeObserverItemFinalElement + _strDivEnd; - observerDOM += strDivEnd; - observerDOM += _strDivBegin + _classNameResizeObserverItemElement + strDivClose; - observerDOM += _strDivBegin + _classNameResizeObserverItemFinalElement + '" style="width: 200%; height: 200%' + _strDivEnd; - observerDOM += strDivEnd; - observerDOM += strDivEnd; - observerDOM += strDivEnd; - - targetElement.prepend(observerDOM); - targetElement = targetElement[0]; - var observerElement = targetElement[strChildNodes][0][strChildNodes][0]; - var shrinkElement = helper(observerElement[strChildNodes][1]); - var expandElement = helper(observerElement[strChildNodes][0]); - var expandElementChild = helper(expandElement[0][strChildNodes][0]); - var widthCache = observerElement[WORDING.oW]; - var heightCache = observerElement[WORDING.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[WORDING.oW] + nativeScrollbarSize.x * factor + nativeScrollbarSize.y * factor + _overlayScrollbarDummySize.x + _overlayScrollbarDummySize.y; - var sizeResetHeight = observerElement[WORDING.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[WORDING.oW]; - currHeight = observerElement[WORDING.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 observerElementCSS = {}; - observerElementCSS[_strTop] = (-((nativeScrollbarSize.y + 1) * factor)); - observerElementCSS[_strRight] = (nativeScrollbarSize.x * -factor); - observerElementCSS[_strBottom] = (nativeScrollbarSize.y * -factor); - observerElementCSS[_strLeft] = (-((nativeScrollbarSize.x + 1) * factor)); - - helper(observerElement).css(observerElementCSS); - expandElement.on(_strScroll, onScroll); - shrinkElement.on(_strScroll, onScroll); - helper(targetElement).on(strAnimationStartEvent, function () { - onScroll(false); - }); - //lets assume that the divs will never be that large and a constant value is enough - var expandChildCSS = {}; - expandChildCSS[_strWidth] = constMaximum; - expandChildCSS[_strHeight] = constMaximum; - expandElementChild.css(expandChildCSS); - - reset(); - } - else { - var doc = _documentElement[0]; - var JQelement = targetElement; - targetElement = targetElement[0]; - var attachEvent = doc.attachEvent; - var isIE = typeof navigator !== TYPES.u ? navigator.userAgent.match(/Trident/) || navigator.userAgent.match(/Edge/) : true; - if (attachEvent) { - JQelement.prepend(_strDivBegin + _classNameResizeObserverElement + _strDivEnd); - JQelement.find(_strDot + _classNameResizeObserverElement).first()[0].attachEvent('onresize', callback); - } - else { - var obj = doc.createElement(TYPES.o); - obj.setAttribute('tabindex', '-1'); - obj.setAttribute(WORDING.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) - JQelement.prepend(obj); - obj.data = 'about:blank'; - if (!isIE) - JQelement.prepend(obj); - JQelement.on(strAnimationStartEvent, callback); - } - } - } - - //direction change detection: - targetElement = helper(targetElement); - if (targetElement[0] === _sizeObserverElement[0]) { - var directionChanged = function () { - var dir = _hostElement.css('direction'); - if (dir !== _cssDirectionDetectedCache) { - var css = {}; - var scrollLeftValue = 0; - 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().first().css(css); - targetElement.scrollLeft(scrollLeftValue); - targetElement.scrollTop(constMaximum); - _cssDirectionDetectedCache = dir; - return true; - } - return false; - }; - 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 { - targetElement.children(_strDot + _classNameResizeObserverElement).first().remove(); - } - } - - /** - * 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; - } - - /** - * Calls the given callback with the given args. The Context of this callback is always _base (this). - * @param callback The callback function which shall be called. - * @param args The args with which the callback shall be called. - */ - function callCallback(callback, args) { - if(_initialized) - callback.call(_base, 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]; - } - - /** - * Connects the MutationObservers if they are supported. - */ - function mutationObserversConnect() { - if (_supportMutationObserver && !_mutationObserverConnected) { - _mutationObserverHost.observe(_hostElement[0], { - attributes: true, - attributeOldValue: true, - attributeFilter: [WORDING.i, WORDING.c, WORDING.s] - }); - - _mutationObserverContent.observe(_isTextarea ? _targetElement[0] : _contentElement[0], { - attributes: true, - attributeOldValue: true, - subtree: !_isTextarea, - childList: !_isTextarea, - characterData: !_isTextarea, - attributeFilter: _isTextarea ? ['wrap', 'cols', 'rows'] : [WORDING.i, WORDING.c, WORDING.s] - }); - - _mutationObserverConnected = true; - } - } - - /** - * Disconnects the MutationObservers if they are supported. - */ - function mutationObserversDisconnect() { - if (_supportMutationObserver && _mutationObserverConnected) { - _mutationObserverHost.disconnect(); - _mutationObserverContent.disconnect(); - - _mutationObserverConnected = 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][WORDING.oW] - (!_isBorderBox ? _paddingX : 0); - _resizeDragStartSize.h = _hostElement[0][WORDING.oH] - (!_isBorderBox ? _paddingY : 0); - - _documentElement.on(_strSelectStartEvent, onSelectStart) - .on(_strMouseTouchMoveEvent, scrollbarCornerOnResize) - .on(_strMouseTouchUpEvent, scrollbarCornerOnResized); - - _bodyElement.addClass(_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 originalEvent = event.originalEvent || 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, onSelectStart) - .off(_strMouseTouchMoveEvent, scrollbarCornerOnResize) - .off(_strMouseTouchUpEvent, scrollbarCornerOnResized); - - _bodyElement.removeClass(_classNameDragging); - if (_scrollbarCornerElement.releaseCapture) - _scrollbarCornerElement.releaseCapture(); - - if (eventIsTrusted) { - if (_resizeReconnectMutationObserver) - mutationObserversConnect(); - _base.update(_strAuto); - } - _resizeReconnectMutationObserver = false; - } - - /** - * 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]; - - //reset min size - css[_strMinMinus + _strWidth] = _strEmpty; - css[_strMinMinus + _strHeight] = _strEmpty; - - //set width auto - css[_strWidth] = _strAuto; - _targetElement.css(css); - - //measure width - var origWidth = measureElement[WORDING.oW]; - var width = doMeasure ? Math.max(origWidth, measureElement[WORDING.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 - var origHeight = measureElement[WORDING.oH]; - var height = Math.max(origHeight, measureElement[WORDING.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 - }; - } - - /** - * 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.prop('selectionStart'); - if (textareaCursorPosition === undefined) - return; - var textareaValue = _targetElement.val(); - var textareaLength = textareaValue.length; - var textareaRowSplit = textareaValue.split("\n"); - var textareaLastRow = textareaRowSplit.length; - var textareaCurrentCursorRowSplit = textareaValue.substr(0, textareaCursorPosition).split("\n"); - var widestRow = 0; - var textareaLastCol = 0; - var cursorRow = textareaCurrentCursorRowSplit.length; - var cursorCol = textareaCurrentCursorRowSplit[textareaCurrentCursorRowSplit.length - 1].length; - - //get widest Row and the last column of the textarea - for (var i = 0; i < textareaRowSplit.length; i++) { - var rowCols = textareaRowSplit[i].length; - if (rowCols > textareaLastCol) { - widestRow = i + 1; - textareaLastCol = rowCols; - } - } - - return { - cursorRow: cursorRow, - cursorCol: cursorCol, - rows: textareaLastRow, - cols: textareaLastCol, - wRow: widestRow, - pos: textareaCursorPosition, - max: textareaLength - }; - } - - /** - * 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; - } - - /** - * 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 (helper.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 = helper.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 () { - 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; - } - - /** - * 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 onSelectStart(event) { - compatibility.prvD(event); - return false; - } - - /** - * A callback which will be called after a img element has downloaded its src asynchronous. - */ - function onImgLoad() { - update(); - } - - /** - * 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)); - } - - /** - * 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) - _hostElement.removeClass(scrollbarClassName); - else - _hostElement.addClass(scrollbarClassName); - - if (canScroll) - scrollbarElement.removeClass(_classNameScrollbarUnusable); - else - scrollbarElement.addClass(_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) - _scrollbarHorizontalElement.removeClass(_classNameScrollbarAutoHidden); - //if(_hasOverflowCache.y && _hideOverflowCache.ys) - _scrollbarVerticalElement.removeClass(_classNameScrollbarAutoHidden); - } - else { - var strActive = 'active'; - var hide = function () { - if (!_scrollbarsAutoHideFlagScrollAndHovered) { - var anyActive = _scrollbarHorizontalHandleElement.hasClass(strActive) || _scrollbarVerticalHandleElement.hasClass(strActive); - if (!anyActive && (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove || _scrollbarsAutoHideLeave)) - _scrollbarHorizontalElement.addClass(_classNameScrollbarAutoHidden); - if (!anyActive && (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove || _scrollbarsAutoHideLeave)) - _scrollbarVerticalElement.addClass(_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); - - //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 * 100000) / 100000) + "%"; //the last * 100000 / 100000 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); - - //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]; - - //if rtl scroll max is negative - if (_rtlScrollBehavior.n && isRTLisHorizontal) - maxScroll *= -1; - - var 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 - - var handleLength = scrollbarVars.i.hl; - var trackLength = scrollbarVars.t[0]['offset' + scrollbarVars.WH]; - var handleTrackDiff = trackLength - handleLength; - var offset = handleTrackDiff * posRatio; - offset = isNaN(offset) ? 0 : offset; - if (isRTLisHorizontal && (_rtlScrollBehavior.n || !_rtlScrollBehavior.n && !_rtlScrollBehavior.i)) - offset = trackLength - handleLength - offset; - offset = Math.max(0, offset); - - if (_supportTransform) { - if (isRTLisHorizontal) - offset = -(trackLength - handleLength - offset); - var translateValue; - var strTranslateBrace = 'translate('; - var strTransform = 'transform'; - if (isHorizontal) - translateValue = strTranslateBrace + offset + 'px, 0px)'; - else - translateValue = strTranslateBrace + '0px, ' + offset + '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); - } - - /** - * Builds all scrollbars if they aren't already build. - */ - function buildScrollbars() { - _scrollbarHorizontalElement = helper(_strDivBegin + _classNameScrollbar + _strSpace + _classNameScrollbarHorizontal + _strDivEnd); - _scrollbarHorizontalTrackElement = helper(_strDivBegin + _classNameScrollbarTrack + _strDivEnd); - _scrollbarHorizontalHandleElement = helper(_strDivBegin + _classNameScrollbarHandle + _strDivEnd); - _scrollbarVerticalElement = helper(_strDivBegin + _classNameScrollbar + _strSpace + _classNameScrollbarVertical + _strDivEnd); - _scrollbarVerticalTrackElement = helper(_strDivBegin + _classNameScrollbarTrack + _strDivEnd); - _scrollbarVerticalHandleElement = helper(_strDivBegin + _classNameScrollbarHandle + _strDivEnd); - - _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 = helper(_strDivBegin + _strSpace + _classNameScrollbarCorner + _strDivEnd); - _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 mouseDownScroll; - var mouseDownOffset; - var xy = scrollbarVars.xy; - var scroll = _strScroll + scrollbarVars.LT; - var strActive = 'active'; - var trackTimeout; - var scrollDurationFactor = 1; - var increaseTrackScrollAmount = function () { - scrollDurationFactor = 0.5; - }; - var decreaseTrackScrollAmount = function () { - scrollDurationFactor = 1; - }; - var handleDragMove = function (event) { - var originalEvent = event.originalEvent || event; - var trackLength = scrollbarVars.i.tl; - var handleLength = scrollbarVars.i.hl; - var scrollRange = scrollbarVars.i.ms; - var scrollRaw = (handleLength / 2) + compatibility.page(event)[xy] - mouseDownOffset; - var scrollDeltaPercent = (scrollRaw - (handleLength / 2)) / (trackLength - handleLength); - var scrollDelta = (scrollRange * scrollDeltaPercent); - scrollDelta = isFinite(scrollDelta) ? scrollDelta : 0; - if (_isRTL && isHorizontal && (_rtlScrollBehavior.n || !_rtlScrollBehavior.n && !_rtlScrollBehavior.i)) - scrollDelta *= -1; - _viewportElement[scroll](mouseDownScroll + scrollDelta); - - if (!_supportPassiveEvents) - compatibility.prvD(event); - }; - var documentMouseTouchUp = function (event) { - event = event || event.originalEvent; - _bodyElement.removeClass(_classNameDragging); - scrollbarVars.h.removeClass(strActive); - scrollbarVars.t.removeClass(strActive); - scrollbarVars.s.removeClass(strActive); - - if (_supportPassiveEvents) { - removePassiveEventListener(_documentElement, _strMouseTouchMoveEvent, handleDragMove); - removePassiveEventListener(_documentElement, _strMouseTouchUpEvent, documentMouseTouchUp); - removePassiveEventListener(_documentElement, _strKeyDownEvent, documentKeyDown); - removePassiveEventListener(_documentElement, _strKeyUpEvent, documentKeyUp); - } - else { - _documentElement.off(_strMouseTouchMoveEvent, handleDragMove) - .off(_strMouseTouchUpEvent, documentMouseTouchUp) - .off(_strKeyDownEvent, documentKeyDown) - .off(_strKeyUpEvent, documentKeyUp); - } - _documentElement.off(_strSelectStartEvent, onSelectStart); - - decreaseTrackScrollAmount(); - mouseDownScroll = undefined; - mouseDownOffset = undefined; - if (trackTimeout !== undefined) { - _base.scrollStop(); - clearTimeout(trackTimeout); - trackTimeout = undefined; - } - - //if mouse is outside host element - var rect = _hostElement[0].getBoundingClientRect(); - if (!(event.clientX >= rect.left && event.clientX <= rect.right && - event.clientY >= rect.top && event.clientY <= rect.bottom)) { - hostOnMouseLeave(); - } - if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) - refreshScrollbarsAutoHide(false); - }; - var documentKeyDown = function (event) { - if (event.keyCode == 16) - increaseTrackScrollAmount(); - }; - var documentKeyUp = function (event) { - if (event.keyCode == 16) - decreaseTrackScrollAmount(); - }; - scrollbarVars.h.on(_strMouseTouchDownEvent, function (event) { - if (_isSleeping) - return; - - var originalEvent = event.originalEvent || event; - var isTouchEvent = originalEvent.touches !== undefined; - if (nativeOverlayScrollbarsAreActive() || !_scrollbarsDragScrollingCache || (isTouchEvent && !_scrollbarsTouchSupport)) - return; - - if (compatibility.mBtn(event) === 1 || isTouchEvent) { - mouseDownScroll = _viewportElement[scroll](); - mouseDownScroll = mouseDownScroll === undefined ? 0 : mouseDownScroll; - if (_isRTL && isHorizontal && !_rtlScrollBehavior.n || !_isRTL) - mouseDownScroll = mouseDownScroll < 0 ? 0 : mouseDownScroll; - mouseDownOffset = compatibility.page(event)[xy]; - - _bodyElement.addClass(_classNameDragging); - scrollbarVars.h.addClass(strActive); - scrollbarVars.s.addClass(strActive); - - if (_supportPassiveEvents) { - addPassiveEventListener(_documentElement, _strMouseTouchMoveEvent, handleDragMove); - addPassiveEventListener(_documentElement, _strMouseTouchUpEvent, documentMouseTouchUp); - } - else { - _documentElement.on(_strMouseTouchMoveEvent, handleDragMove) - .on(_strMouseTouchUpEvent, documentMouseTouchUp); - } - _documentElement.on(_strSelectStartEvent, onSelectStart); - compatibility.prvD(event); - } - }); - scrollbarVars.t.on(_strMouseTouchDownEvent, function (event) { - if (_isSleeping) - return; - - var originalEvent = event.originalEvent || event; - var isTouchEvent = originalEvent.touches !== undefined; - if (nativeOverlayScrollbarsAreActive() || !_scrollbarsClickScrollingCache || (isTouchEvent && !_scrollbarsTouchSupport)) - return; - - if (compatibility.mBtn(event) === 1 || isTouchEvent) { - var scrollDistance = _viewportSize[scrollbarVars._wh]; - var trackOffset = scrollbarVars.t.offset()[scrollbarVars.lt]; - var decreaseScroll; - var isFirstIteration = true; - if (event.shiftKey) - increaseTrackScrollAmount(); - var scrollAction = function () { - var handleOffset = scrollbarVars.i.ho; - var handleLength = scrollbarVars.i.hl; - var mouseOffset = mouseDownOffset - trackOffset; - var scrollDuration = 200 * scrollDurationFactor; - var timeoutDelay = isFirstIteration ? Math.max(333, scrollDuration) : scrollDuration; - var scrollObj = {}; - var rtlIsNormal = _isRTL && isHorizontal && ((!_rtlScrollBehavior.i && !_rtlScrollBehavior.n) || _normalizeRTLCache); - var decreaseScrollCondition = handleOffset > mouseOffset; - - if (rtlIsNormal) - decreaseScrollCondition = handleOffset < mouseOffset; - - if (decreaseScrollCondition) { - if (decreaseScroll === undefined) - decreaseScroll = true; - scrollObj[scrollbarVars.xy] = '-=' + scrollDistance; - } - else { - if (decreaseScroll === undefined) - decreaseScroll = false; - scrollObj[scrollbarVars.xy] = '+=' + scrollDistance; - } - _base.scrollStop(); - _base.scroll(scrollObj, scrollDuration, 'linear'); - - var finishedCondition = decreaseScroll ? handleOffset <= mouseOffset : handleOffset + handleLength >= mouseOffset; - if (rtlIsNormal) - finishedCondition = decreaseScroll ? handleOffset + handleLength >= mouseOffset : handleOffset <= mouseOffset; - - if (finishedCondition) { - clearTimeout(trackTimeout); - _base.scrollStop(); - trackTimeout = undefined; - } - else - trackTimeout = setTimeout(scrollAction, timeoutDelay); - isFirstIteration = false; - }; - - mouseDownOffset = compatibility.page(event)[xy]; - _bodyElement.addClass(_classNameDragging); - scrollbarVars.t.addClass(strActive); - scrollbarVars.s.addClass(strActive); - - if (_supportPassiveEvents) { - addPassiveEventListener(_documentElement, _strMouseTouchUpEvent, documentMouseTouchUp); - addPassiveEventListener(_documentElement, _strKeyDownEvent, documentKeyDown); - addPassiveEventListener(_documentElement, _strKeyUpEvent, documentKeyUp); - } - else { - _documentElement.on(_strMouseTouchUpEvent, documentMouseTouchUp) - .on(_strKeyDownEvent, documentKeyDown) - .on(_strKeyUpEvent, documentKeyUp); - } - _documentElement.on(_strSelectStartEvent, onSelectStart); - - scrollAction(); - compatibility.prvD(event); - } - }).hover(function () { //make sure both scrollbars will stay visible if one scrollbar is hovered if autoHide is "scroll". - if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) { - _scrollbarsAutoHideFlagScrollAndHovered = true; - refreshScrollbarsAutoHide(true); - } - }, function () { - if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) { - _scrollbarsAutoHideFlagScrollAndHovered = false; - refreshScrollbarsAutoHide(false); - } - }); - scrollbarVars.s.on(_strMouseTouchDownEvent, function (event) { - compatibility.stpP(event); - }); - } - - /** - * 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 - }; - } - - /** - * 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) - 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; - - var optionsCallbacks = _currentPreparedOptions.callbacks; - var onScrollStartCallback = optionsCallbacks.onScrollStart; - var onScrollCallback = optionsCallbacks.onScroll; - var onScrollStopCallback = optionsCallbacks.onScrollStop; - if (_scrollStopTimeoutId !== undefined) - clearTimeout(_scrollStopTimeoutId); - else { - if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) - refreshScrollbarsAutoHide(true); - - if (!nativeOverlayScrollbarsAreActive()) - _hostElement.addClass(_classNameHostScrolling); - - if (helper.isFunction(onScrollStartCallback)) - callCallback(onScrollStartCallback, event); - } - - refreshScrollbarHandleOffset(true, _viewportElement[_strScrollLeft]()); - refreshScrollbarHandleOffset(false, _viewportElement[_strScrollTop]()); - - if (helper.isFunction(onScrollCallback)) - callCallback(onScrollCallback, event); - - _scrollStopTimeoutId = setTimeout(function () { - onScrollStop(event); - if (helper.isFunction(onScrollStopCallback)) - callCallback(onScrollStopCallback, event); - }, _scrollStopDelay); - } - - /** - * This method gets called if the scroll event stopped for a specified amount of time. - * @param event The last scroll event which was fired. - */ - function onScrollStop() { - clearTimeout(_scrollStopTimeoutId); - _scrollStopTimeoutId = undefined; - if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) - refreshScrollbarsAutoHide(false); - - if (!nativeOverlayScrollbarsAreActive()) - _hostElement.removeClass(_classNameHostScrolling); - } - - /** - * 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) { - return ( - typeof HTMLElement === TYPES.o ? o instanceof HTMLElement : //DOM2 - o && typeof o === TYPES.o && o !== null && o.nodeType === 1 && typeof o.nodeName === TYPES.s - ); - } - - /** - * Validates a given option and returns the result. - * @param currentOptions Current options object - * @param optionName The option name - * @param optionAllowedValues Allowed Values for this option - * @param removeFromObject Undefined or True to remove the option with the given option name from the given options object. - * @returns {{n: string, s: boolean, v: *, p: *}} - * n = option name - * s = true if option is valid, false otherwise - * v = the original value - * p = the prepared value (may only different from original value if typeof string) - */ - function getValidatedOption(currentOptions, optionName, optionAllowedValues, removeFromObject) { - var returnObj = {n: optionName, s: false, v: undefined, p: undefined}; //name = [name], succes = false, value = undefined, prepared = undefined, - var optionValue; - var optionValueType = TYPES.u; - var optionNameProgression = byPropertyPath.has(currentOptions, optionName); - var currObj = byPropertyPath.get(currentOptions, optionName); - var canBeUndefined = false; - var optionIsInvalid = optionNameProgression !== true; - var strStar = '*'; - var i, v, g; - var optionAllowedValuesLength; - var anyStringAllowed = false; - if (helper.type(optionAllowedValues) !== TYPES.a) - optionAllowedValues = [optionAllowedValues]; - optionAllowedValuesLength = optionAllowedValues.length; - - for (i = 0; i < optionAllowedValuesLength; i++) { - var curr = optionAllowedValues[i]; - if (curr === strStar) { - if (optionAllowedValuesLength > 1) { - var count = 0; - for (g = 0; g < optionAllowedValuesLength; g++) { - var check = optionAllowedValues[g]; - if (helper.type(check) === TYPES.s) { - count++; - if (count > 1) - break; - } - } - if (count === 1) - anyStringAllowed = true; - } + if (contents.length) + contents.wrapAll(wrapperHTML); else - anyStringAllowed = true; + el.append(wrapperHTML); + }); + }, + + wrap : function(wrapperHTML) { + return this.each(function() { new FakejQuery(this).wrapAll(wrapperHTML); }); + }, + + contents : function() { + var contents = [ ]; + var childs; + var i; + + this.each(function() { + childs = this.childNodes; + for(i = 0; i < childs.length; i++) + contents.push(childs[i]); + }); + + return new FakejQuery(contents); + }, + + parent : function() { + var parents = [ ]; + this.each(function() { parents.push(this.parentNode); }); + return new FakejQuery(parents); + }, + + is : function(selector) { + var el; + var i; + for(i = 0; i < this.length; i++) { + el = this[i]; + if(selector === ":visible") + return el.style.display !== 'none'; + if(selector === ":hidden") + return el.style.display === 'none'; + if((el.matches && el.matches(selector)) || matches(el, selector)) + return true; } - if (curr === undefined) - canBeUndefined = true; + return false; + }, + + animate : function(props, duration, easing, complete) { + return this.each(function() { animate(this, props, duration, easing, complete); }); + }, + + stop : function(clearQ, jump) { + return this.each(function() { stop(this, clearQ, jump); }); } + }; - if (optionIsInvalid && optionNameProgression === false && canBeUndefined) - optionIsInvalid = false; + extend(FakejQuery, { + extend : extend, + type : type, + isFunction : isFunction, + isArray : isArray, + isEmptyObject : isEmptyObject, + isPlainObject : isPlainObject, + inArray : inArray, + each : each + }); - if (!optionIsInvalid) { - optionValue = currObj; - optionValueType = helper.type(optionValue); - var checkOption = function (allowedValue) { - var valueType = helper.type(allowedValue); - var correct = false; - if (valueType === optionValueType) { - if (valueType === TYPES.s) { - correct = anyStringAllowed ? true : optionValue === allowedValue; - } - else { - correct = true; - } - if (correct) { - returnObj.s = true; - returnObj.v = optionValue; - returnObj.p = optionValue; - return true; - } + return FakejQuery; + })(COMPATIBILITY); + var INSTANCES = (function(helper) { + var _targets = [ ]; + var _instancePropertyString = '__overlayScrollbars__'; + + /** + * Registers the given instance to the given element. + * @param target The target element. + * @param instance The instance. + */ + function registerInstanceToTarget(target, instance) { + target[_instancePropertyString] = instance; + _targets.push(target); + } + + /** + * Unregisters the instance from the given element. + * @param target The target element. + */ + function unregisterInstanceFromTarget(target) { + var index = helper.inArray(target, _targets); + if (index > -1) { + delete target[_instancePropertyString]; + _targets.splice(index, 1); + } + } + + /** + * Checks if the target element has a registered instance. + * @param target The target element. + * @returns {boolean} True if the target element is already registered, false otherwise. + */ + function targetHasRegisteredInstance(target) { + return getRegisteredInstanceFromTarget(target) !== undefined; + } + + /** + * Gets the registered instance of the given element. + * @param target The target element. + * @returns {*} The registered instance of the target or undefined if there isn't any. + */ + function getRegisteredInstanceFromTarget(target) { + for(var i = 0; i < _targets.length; i++) + if(target === _targets[i]) + return target[_instancePropertyString]; + + } + + return { + all : function() { + return _targets; + }, + add : registerInstanceToTarget, + rem : unregisterInstanceFromTarget, + has : targetHasRegisteredInstance, + get : getRegisteredInstanceFromTarget + }; + })(FRAMEWORK); + var PLUGIN = (function(compatibility, instances, helper) { + var _pluginsGlobals; + var _pluginsAutoUpdateLoop; + var _pluginsOptions = (function() { + var possibleTemplateTypes = [ + TYPES.b, //boolean + TYPES.n, //number + TYPES.s, //string + TYPES.a, //array + TYPES.o, //object + TYPES.f, //function + TYPES.z //null + ]; + var restrictedStringsSplit = " "; + var restrictedStringsPossibilitiesSplit = ":"; + var classNameAllowedValues = [TYPES.z, TYPES.s]; + var booleanAllowedValues = TYPES.b; + var numberAllowedValues = TYPES.n; + var booleanNullAllowedValues = [TYPES.z, booleanAllowedValues]; + var callbackAllowedValues = [TYPES.z, TYPES.f]; + var resizeAllowedValues = 'n:none b:both h:horizontal v:vertical'; + var overflowBehaviorAllowedValues = 'v-h:visible-hidden v-s:visible-scroll s:scroll h:hidden'; + var scrollbarsVisibilityAllowedValues = 'v:visible h:hidden a:auto'; + var scrollbarsAutoHideAllowedValues = 'n:never s:scroll l:leave m:move'; + var optionsDefaultsAndTemplate = { + className: ['os-theme-dark', classNameAllowedValues], //null || string + resize: ['none', resizeAllowedValues], //none || both || horizontal || vertical || n || b || h || v + sizeAutoCapable: [true, booleanAllowedValues], //true || false + clipAlways: [true, booleanAllowedValues], //true || false + normalizeRTL: [true, booleanAllowedValues], //true || false + paddingAbsolute: [false, booleanAllowedValues], //true || false + autoUpdate: [null, booleanNullAllowedValues], //true || false || null + autoUpdateInterval: [33, numberAllowedValues], //number + nativeScrollbarsOverlaid: { + showNativeScrollbars: [false, booleanAllowedValues], //true || false + initialize: [true, booleanAllowedValues] //true || false + }, + overflowBehavior: { + x: ['scroll', overflowBehaviorAllowedValues], //visible-hidden || visible-scroll || hidden || scroll || v-h || v-s || h || s + y: ['scroll', overflowBehaviorAllowedValues] //visible-hidden || visible-scroll || hidden || scroll || v-h || v-s || h || s + }, + scrollbars: { + visibility: ['auto', scrollbarsVisibilityAllowedValues], //visible || hidden || auto || v || h || a + autoHide: ['never', scrollbarsAutoHideAllowedValues], //never || scroll || leave || move || n || s || l || m + autoHideDelay: [800, numberAllowedValues], //number + dragScrolling: [true, booleanAllowedValues], //true || false + clickScrolling: [false, booleanAllowedValues], //true || false + touchSupport: [true, booleanAllowedValues] //true || false + }, + textarea: { + dynWidth: [false, booleanAllowedValues], //true || false + dynHeight: [false, booleanAllowedValues] //true || false + }, + callbacks: { + onInitialized: [null, callbackAllowedValues], //null || function + onInitializationWithdrawn: [null, callbackAllowedValues], //null || function + onDestroyed: [null, callbackAllowedValues], //null || function + onScrollStart: [null, callbackAllowedValues], //null || function + onScroll: [null, callbackAllowedValues], //null || function + onScrollStop: [null, callbackAllowedValues], //null || function + onOverflowChanged: [null, callbackAllowedValues], //null || function + onOverflowAmountChanged: [null, callbackAllowedValues], //null || function + onDirectionChanged: [null, callbackAllowedValues], //null || function + onContentSizeChanged: [null, callbackAllowedValues], //null || function + onHostSizeChanged: [null, callbackAllowedValues], //null || function + onUpdated: [null, callbackAllowedValues] //null || function + } + //extensions : [{ }, TYPES.o] + }; + var convert = function(template) { + var recursive = function(obj) { + var key; + var val; + var valType; + for(key in obj) { + if(!obj.hasOwnProperty(key)) + continue; + val = obj[key]; + valType = helper.type(val); + if(valType === TYPES.a) + obj[key] = val[template ? 1 : 0]; + else if(valType === TYPES.o) + obj[key] = recursive(val); } - return false; + return obj; }; - for (i = 0; i < optionAllowedValuesLength; i++) { - var currPossibleValue = optionAllowedValues[i]; - if (helper.type(currPossibleValue) === TYPES.s) { - var currPossibleValueSplit = currPossibleValue.split(':'); - var key = currPossibleValueSplit[0]; - var breakAll = false; - for (v = 0; v < currPossibleValueSplit.length; v++) { - if (checkOption(currPossibleValueSplit[v])) { - if (!anyStringAllowed) - returnObj.p = key; - breakAll = true; - break; - } - } - if (breakAll) - break; - } - else { - if (checkOption(currPossibleValue)) - break; - } - } - } - if (!returnObj.s) { - var error = "The option \"" + optionName + "\" wasn't set, because"; - if (!optionIsInvalid || optionNameProgression === false) { - var allowedValueTypes = []; - var allowedValueTypesString = _strEmpty; - var hasAllowedStrings = false; - var allowedStringsText = _strEmpty; - for (i = 0; i < optionAllowedValuesLength; i++) { - var value = optionAllowedValues[i]; - var valueType = helper.type(value); - if (valueType === TYPES.s) { - hasAllowedStrings = !anyStringAllowed; - var stringSplit = value.split(':'); - for (v = 0; v < stringSplit.length; v++) { - allowedStringsText += "\"" + stringSplit[v] + "\", "; - } - } - if (helper.inArray(valueType, allowedValueTypes) === -1) { - allowedValueTypes.push(valueType); - allowedValueTypesString = allowedValueTypesString + valueType.toUpperCase() + ", "; - } - } - allowedValueTypesString = allowedValueTypesString.slice(0, -2); - if (hasAllowedStrings) - allowedStringsText = allowedStringsText.slice(0, -2); - console.warn(error + " it doesn't accept the type [ " + optionValueType.toUpperCase() + " ] with the value of \"" + optionValue + "\".\r\n" + - "Accepted types are: [ " + allowedValueTypesString + " ]." + - (hasAllowedStrings ? "\r\nValid strings are: [ " + allowedStringsText + " ]." : _strEmpty)); - } - else { - var isDefaultOption = byPropertyPath.has(_defaultOptions, optionName); - if (isDefaultOption === true) { - console.warn(error + " \"" + optionNameProgression + "\" is not from type [ OBJECT ]."); - } - else { - error = "The option \"" + optionName + "\" is not a default option"; - if (isDefaultOption === false) - console.warn(error + _strDot); - else - console.warn(error + " and couldn't be resolved, because \"" + isDefaultOption + "\" is not from type [ OBJECT ]."); - } - } - } - removeFromObject = removeFromObject === undefined ? true : removeFromObject; - if (removeFromObject) - byPropertyPath.del(currentOptions, optionName); - return returnObj; - } + return recursive(helper.extend(true, { }, optionsDefaultsAndTemplate)); + }; - /** - * 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 = parseIntToZeroOrNumber(_contentArrangeElement.css(_strMinMinus + _strWidth)); - bodyMinSize.h = parseIntToZeroOrNumber(_contentArrangeElement.css(_strMinMinus + _strHeight)); - bodyMinSize.c = checkCacheDouble(bodyMinSize, _bodyMinSizeCache); - bodyMinSize.f = true; //flag for "measured at least once" - } - _bodyMinSizeCache = bodyMinSize; - return bodyMinSize.c; - } + return { + //defaults + d : convert(), - /** - * Builds a new object which consists of all valid options in the given options array. - * @param validatedOptionsArray The array of validated options - * @param usePreparedValues True for prepared values, False for original values (these two may only differ if they are typeof string) - * @returns {{}} A new object which consists of all valid options from the given array. - */ - function buildValidatedOptionsObject(validatedOptionsArray, usePreparedValues) { - var returnObj = {}; - var i, v; - for (i = 0; i < validatedOptionsArray.length; i++) { - var currValidatedOption = validatedOptionsArray[i]; - var objects = []; - if (currValidatedOption.s) { - var propertyString = currValidatedOption.n; - var propertyStingSplit = propertyString.split('.'); + //template + t : convert(true), - for (v = 0; v < propertyStingSplit.length; v++) { - objects[v] = {}; - objects[v][propertyStingSplit[v]] = {}; - } - for (v = 0; v < objects.length; v++) { - var set = false; - var currObj = objects[v]; - if (v + 1 === objects.length) - set = true; + //validate + /** + * Validates the passed object by the passed template. + * @param obj The object which shall be validated. + * @param template The template which defines the allowed values and types. + * @param writeErrors True if errors shall be logged to the console. + * @param usePreparedValues True if the validated main values shall be returned in the validated object, false otherwise. + * @param keepForeignProps True if properties which aren't in the template shall be added to the validated object, false otherwise. + * @returns {{}} A object which contains only the valid properties of the passed original object. + */ + v : function (obj, template, writeErrors, usePreparedValues, keepForeignProps) { + var validatedOptions = { }; + var objectCopy = helper.extend(true, { }, obj); + var checkObjectProps = function(data, template, validatedOptions, prevPropName) { + for (var prop in template) { + if (template.hasOwnProperty(prop) && data.hasOwnProperty(prop)) { + var isValid = false; + var templateValue = template[prop]; + var templateValueType = helper.type(templateValue); + var templateTypes = helper.type(templateValue) !== TYPES.a ? [ templateValue ] : templateValue; + var dataValue = data[prop]; + var dataValueType = helper.type(dataValue); + var propPrefix = prevPropName ? prevPropName + "." : ""; + var error = "The option \"" + propPrefix + prop + "\" wasn't set, because"; + var errorPossibleTypes = [ ]; + var errorRestrictedStrings = [ ]; + var restrictedStringValuesSplit; + var restrictedStringValuesPossibilitiesSplit; + var isRestrictedValue; + var mainPossibility; + var currType; + var i; + var v; + var j; - for (var property in currObj) { - if (currObj.hasOwnProperty(property)) { - currObj[property] = objects[v + 1]; - if (set) { - if (usePreparedValues) - currObj[property] = currValidatedOption.p; - else - currObj[property] = currValidatedOption.v; + //if the template has a object as value, it means that the options are complex (verschachtelt) + if(templateValueType === TYPES.o) { + validatedOptions[prop] = { }; + checkObjectProps(dataValue, templateValue, validatedOptions[prop], propPrefix + prop); + if(helper.isEmptyObject(dataValue)) + delete data[prop]; + } + else { + for(i = 0; i < templateTypes.length; i++) { + currType = templateTypes[i]; + templateValueType = helper.type(currType); + //if currtype is string and starts with restrictedStringPrefix and end with restrictedStringSuffix + isRestrictedValue = templateValueType === TYPES.s && helper.inArray(currType, possibleTemplateTypes) === -1; + if(isRestrictedValue) { + errorPossibleTypes.push(TYPES.s); + + //split it into a array which contains all possible values for example: ["y:yes", "n:no", "m:maybe"] + restrictedStringValuesSplit = currType.split(restrictedStringsSplit); + errorRestrictedStrings = errorRestrictedStrings.concat(restrictedStringValuesSplit); + for(v = 0; v < restrictedStringValuesSplit.length; v++) { + //split the possible values into their possibiliteis for example: ["y", "yes"] -> the first is always the mainPossibility + restrictedStringValuesPossibilitiesSplit = restrictedStringValuesSplit[v].split(restrictedStringsPossibilitiesSplit); + mainPossibility = restrictedStringValuesPossibilitiesSplit[0]; + for(j = 0; j < restrictedStringValuesPossibilitiesSplit.length; j++) { + //if any possibility matches with the dataValue, its valid + if(dataValue === restrictedStringValuesPossibilitiesSplit[j]) { + isValid = true; + break; + } + } + if(isValid) + break; + } + } + else { + errorPossibleTypes.push(currType); + + if(dataValueType === currType) { + isValid = true; + break; + } + } + } + + if(isValid) { + validatedOptions[prop] = isRestrictedValue && usePreparedValues ? mainPossibility : dataValue; + } + else if(writeErrors) { + console.warn(error + " it doesn't accept the type [ " + dataValueType.toUpperCase() + " ] with the value of \"" + dataValue + "\".\r\n" + + "Accepted types are: [ " + errorPossibleTypes.join(", ").toUpperCase() + " ]." + + (errorRestrictedStrings.length > 0 ? "\r\nValid strings are: [ " + errorRestrictedStrings.join(", ").split(restrictedStringsPossibilitiesSplit).join(", ") + " ]." : "")); + } + delete data[prop]; } } } + }; + checkObjectProps(objectCopy, template, validatedOptions); + + //add values which aren't specified in the template to the finished validated object to prevent them from being discarded + if(keepForeignProps) + helper.extend(true, validatedOptions, objectCopy); + else if(!helper.isEmptyObject(objectCopy) && writeErrors) + console.warn("The following options are discarded due to invalidity:\r\n" + JSON.stringify(objectCopy, null, 2)); + + return validatedOptions; + } + } + }()); + + /** + * Initializes the object which contains global information about the plugin and each instance of it. + */ + function initOverlayScrollbarsStatics() { + if(!_pluginsGlobals) + _pluginsGlobals = new OverlayScrollbarsGlobals(_pluginsOptions.d); + if(!_pluginsAutoUpdateLoop) + _pluginsAutoUpdateLoop = new OverlayScrollbarsAutoUpdateLoop(_pluginsGlobals); + } + + /** + * The global object for the hide scrollbars objects. It contains resources which every hide scrollbars object needs. This object is initialized only once: if the first hide scrollbars object gets initialized. + * @param defaultOptions + * @constructor + */ + function OverlayScrollbarsGlobals(defaultOptions) { + var _base = this; + var strOverflow = 'overflow'; + var strHidden = 'hidden'; + var strScroll = 'scroll'; + var bodyElement = helper('body'); + var scrollbarDummyElement = helper('
'); + var scrollbarDummyElement0 = scrollbarDummyElement[0]; + var dummyContainerChild = helper(scrollbarDummyElement.children('div').first()); + var IEBUGFIX = scrollbarDummyElement0[LEXICON.oH]; //IE9 causes a bug where offsetHeight is zero for no reason + + bodyElement.append(scrollbarDummyElement); + if(IEBUGFIX === 0) + scrollbarDummyElement.hide().show(); + + var nativeScrollbarSize = calcNativeScrollbarSize(scrollbarDummyElement0); + var nativeScrollbarIsOverlaid = { + x: nativeScrollbarSize.x === 0, + y: nativeScrollbarSize.y === 0 + }; + + helper.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 = false; + 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.style.cssText = 'width:' + prop + '(1px);'; + if (dummy.style.length) + return prop; } - helper.extend(true, returnObj, objects[0]); + 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 windowWidth = compatibility.wW(); + var windowHeight = compatibility.wH(); + var windowDpr = getWindowDPR(); + + function differenceIsBiggerThanOne(valOne, valTwo) { + var absValOne = Math.abs(valOne); + var absValTwo = Math.abs(valTwo); + return !(absValOne === absValTwo || absValOne + 1 === absValTwo || absValOne - 1 === absValTwo); } - } - return returnObj; - } - /** - * 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; - 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; + function getWindowDPR() { + var dDPI = window.screen.deviceXDPI || 0; + var sDPI = window.screen.logicalXDPI || 1; + return window.devicePixelRatio || (dDPI / sDPI); } - } - for (var k in a) { - diff.push(k); - } - return diff; - } - /** - * 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]; + helper(window).on('resize', function() { + if(instances.all().length > 0) { + var newW = compatibility.wW(); + var newH = compatibility.wH(); + var deltaW = newW - windowWidth; + var deltaH = newH - windowHeight; - //remove none theme from diff list to prevent update - var idx = helper.inArray(_classNameThemeNone, diff); - if (idx > -1) - diff.splice(idx, 1); + if (deltaW === 0 && deltaH === 0) + return; - for (var i = 0; i < diff.length; i++) { - var curr = diff[i]; - if (curr.indexOf(_classNameHostElement) !== 0) { - var v; - var o = true; - var c = true; - for (v = 0; v < oldClassNames.length; v++) { - if (curr === oldClassNames[v]) { - o = false; + var deltaWRatio = Math.round(newW / (windowWidth / 100.0)); + var deltaHRatio = Math.round(newH / (windowHeight / 100.0)); + var absDeltaW = Math.abs(deltaW); + var absDeltaH = Math.abs(deltaH); + var absDeltaWRatio = Math.abs(deltaWRatio); + var absDeltaHRatio = Math.abs(deltaHRatio); + var newDPR = getWindowDPR(); + + var deltaIsBigger = absDeltaW > 2 && absDeltaH > 2; + var difference = !differenceIsBiggerThanOne(absDeltaWRatio, absDeltaHRatio); + var dprChanged = newDPR !== windowDpr && windowDpr > 0; + var windowResized = !(deltaIsBigger && difference && dprChanged); + + if (!windowResized) { + bodyElement.append(scrollbarDummyElement); + _base.nativeScrollbarSize = calcNativeScrollbarSize(scrollbarDummyElement[0]); + scrollbarDummyElement.remove(); + helper.each(instances.all(), function () { + if(instances.has(this)) + instances.get(this).update('zoom'); + }); + } + + windowWidth = newW; + windowHeight = newH; + windowDpr = newDPR; + } + }); + })(); + + 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.style[featurename] !== undefined) + feature = true; + + if (!feature) { + featurenameCapital = featurename.charAt(0).toUpperCase() + featurename.substr(1); + for (; i < domPrefixes.length; i++) { + if (elm.style[domPrefixes[i] + featurenameCapital] !== undefined) { + feature = true; break; } } - for (v = 0; v < currClassNames.length; v++) { - if (curr === currClassNames[v]) { - c = false; - break; - } - } - if (o && c) { - changed = true; - break; - } } - + return feature; } - 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; - - if (mutationTarget === _contentElement[0]) - return attributeName === null; - if (mutationType === 'attributes' && (attributeName === WORDING.c || attributeName === WORDING.s) && !_isTextarea) { - //only do it of browser support it natively - if (typeof mutationTarget.closest !== TYPES.f) - return true; - if (mutationTarget.closest(_strDot + _classNameResizeObserverElement) !== null || - mutationTarget.closest(_strDot + _classNameScrollbar) !== null || - mutationTarget.closest(_strDot + _classNameScrollbarCorner) !== null) - return false; - } - return true; - } - - /** - * Sets new options but doesn't call the update method. - * @param newOptions The object which contains the new options. - */ - function setOptions(newOptions) { - newOptions = helper.extend(true, {}, _currentOptions, newOptions); - var classNameAllowedValues = ['*', null]; - var overflowBehaviorAllowedValues = ['v-h:visible-hidden', 'v-s:visible-scroll', 's:scroll', 'h:hidden']; - var scrollbarsVisibilityAllowedValues = ['v:visible', 'h:hidden', 'a:auto']; - var scrollbarsAutoHideAllowedValues = ['n:never', 's:scroll', 'l:leave', 'm:move']; - var resizeAllowedValues = ['n:none', 'b:both', 'h:horizontal', 'v:vertical']; - var strCallbacksDot = 'callbacks.'; - var strScrollbarsDot = _strScrollbar + 's.'; - var strTextareaDot = 'textarea.'; - var strOverflowBehaviorDot = 'overflowBehavior.'; - var strNativeScrollbarsOverlaidDot = 'nativeScrollbarsOverlaid.'; - - var booleanAllowedValues = true; - var booleanNullAllowedValues = [booleanAllowedValues, null]; - var numberAllowedValues = 0; - var callbackAllowedValues = [new Function(), null]; - - var validatedOptions = [ - getValidatedOption(newOptions, strNativeScrollbarsOverlaidDot + 'showNativeScrollbars', booleanAllowedValues), - getValidatedOption(newOptions, strNativeScrollbarsOverlaidDot + 'initialize', booleanAllowedValues), - getValidatedOption(newOptions, strOverflowBehaviorDot + _strX, overflowBehaviorAllowedValues), - getValidatedOption(newOptions, strOverflowBehaviorDot + _strY, overflowBehaviorAllowedValues), - getValidatedOption(newOptions, strScrollbarsDot + 'visibility', scrollbarsVisibilityAllowedValues), - getValidatedOption(newOptions, strScrollbarsDot + 'autoHide', scrollbarsAutoHideAllowedValues), - getValidatedOption(newOptions, strScrollbarsDot + 'autoHideDelay', numberAllowedValues), - getValidatedOption(newOptions, strScrollbarsDot + 'clickScrolling', booleanAllowedValues), - getValidatedOption(newOptions, strScrollbarsDot + 'dragScrolling', booleanAllowedValues), - getValidatedOption(newOptions, strScrollbarsDot + 'touchSupport', booleanAllowedValues), - getValidatedOption(newOptions, strTextareaDot + 'dynWidth', booleanAllowedValues), - getValidatedOption(newOptions, strTextareaDot + 'dynHeight', booleanAllowedValues), - getValidatedOption(newOptions, 'className', classNameAllowedValues), - getValidatedOption(newOptions, 'resize', resizeAllowedValues), - getValidatedOption(newOptions, 'sizeAutoCapable', booleanAllowedValues), - getValidatedOption(newOptions, 'paddingAbsolute', booleanAllowedValues), - getValidatedOption(newOptions, 'clipAlways', booleanAllowedValues), - getValidatedOption(newOptions, 'normalizeRTL', booleanAllowedValues), - getValidatedOption(newOptions, 'autoUpdate', booleanNullAllowedValues), - getValidatedOption(newOptions, 'autoUpdateInterval', numberAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onInitialized', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onInitializationWithdrawn', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onDestroyed', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onScrollStart', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onScroll', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onScrollStop', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onDirectionChanged', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onContentSizeChanged', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onHostSizeChanged', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onOverflowChanged', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onOverflowAmountChanged', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onUpdated', callbackAllowedValues) - ]; - - for (var prop in newOptions) { - if (newOptions.hasOwnProperty(prop)) { - if (byPropertyPath.has(_defaultOptions, prop)) { - if (helper.isEmptyObject(newOptions[prop])) - delete newOptions[prop]; - } - } - } - if (!helper.isEmptyObject(newOptions)) { - var prepare = function (obj) { - helper.each(obj, function (i, v) { - if (helper.isPlainObject(v)) - prepare(v); - else if (helper.type(v) === TYPES.f) - obj[i] = helper.type(v); - }); + function calcNativeScrollbarSize(measureElement) { + return { + x: measureElement[LEXICON.oH] - measureElement[LEXICON.cH], + y: measureElement[LEXICON.oW] - measureElement[LEXICON.cW] }; - prepare(newOptions); - console.warn("The following options are discarded due to invalidity:\r\n" + JSON.stringify(newOptions, null, 2)); } - - _currentOptions = helper.extend(true, {}, _currentOptions, buildValidatedOptionsObject(validatedOptions, false)); - _currentPreparedOptions = helper.extend(true, {}, _currentPreparedOptions, buildValidatedOptionsObject(validatedOptions, 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. + * The object which manages the auto update loop for all hide scrollbars objects. This object is initialized only once: if the first hide scrollbars object gets initialized. + * @constructor */ - function updateAutoContentSizeChanged() { - if (_isSleeping) - return false; + function OverlayScrollbarsAutoUpdateLoop(globals) { + var _base = this; + var _strAutoUpdate = 'autoUpdate'; + var _strAutoUpdateInterval = _strAutoUpdate + 'Interval'; - var textareaValueLength = _isTextarea && _widthAutoCache && !_textareaAutoWrappingCache ? _targetElement.val().length : 0; - var float; - var setCSS = !_mutationObserverConnected && _widthAutoCache && !_isTextarea; - var css = {}; - if (setCSS) { - float = _contentElement.css(_strFloat); - css[_strFloat] = _isRTL ? _strRight : _strLeft; - css[_strWidth] = _strAuto; - _contentElement.css(css); - } - var contentElementScrollSize = { - w: getContentMeasureElement()[WORDING.sW] + textareaValueLength, - h: getContentMeasureElement()[WORDING.sH] + textareaValueLength - }; - if (setCSS) { - css[_strFloat] = float; - css[_strWidth] = _strHundredPercent; - _contentElement.css(css); - } - var bodyMinSizeC = bodyMinSizeChanged(); - var changed = checkCacheDouble(contentElementScrollSize, _contentElementScrollSizeChangeDetectedCache) || bodyMinSizeC; - _contentElementScrollSizeChangeDetectedCache = contentElementScrollSize; + var _loopingInstances = [ ]; + var _loopingInstancesIntervalCache = [ ]; + var _loopIsActive = false; + var _loopIntervalDefault = 33; + var _loopInterval = _loopIntervalDefault; + var _loopTimeOld = compatibility.now(); + var _loopID; - return changed; - } + /** + * 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.length > 0 && _loopIsActive) { + _loopID = compatibility.rAF()(function () { + loop(); + }); + var timeNew = compatibility.now(); + var timeDelta = timeNew - _loopTimeOld; - /** - * 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(WORDING.i) || _strEmpty; - var hostElementIdChanged = checkCacheSingle(hostElementId, _updateAutoHostElementIdCache); - var hostElementClass = _hostElement.attr(WORDING.c) || _strEmpty; - var hostElementClassChanged = checkCacheSingle(hostElementClass, _updateAutoHostElementClassCache); - var hostElementStyle = _hostElement.attr(WORDING.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; - } - - /** - * Returns Zero or the number to which the value can be parsed. - * @param value The value which shall be parsed. - */ - function parseIntToZeroOrNumber(value) { - var num = window.parseInt(value); - return isNaN(num) ? 0 : num; - } - - /** - * 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 affectingPropsX = [ - _strWidth, - _strMinMinus + _strWidth, - _strMaxMinus + _strWidth, - _strMarginMinus + _strLeft, - _strMarginMinus + _strRight, - _strLeft, - _strRight, - 'font-weight', - 'word-spacing' - ]; - 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' - ]; - 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; + if (timeDelta > _loopInterval) { + _loopTimeOld = timeNew - (timeDelta % _loopInterval); + var lowestInterval = _loopIntervalDefault; + for(var i = 0; i < _loopingInstances.length; 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; } - 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; + /** + * 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(helper.inArray(instance, _loopingInstances) === -1) { + _loopingInstances.push(instance); + _loopingInstancesIntervalCache.push(compatibility.now()); + if (_loopingInstances.length > 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 = helper.inArray(instance, _loopingInstances); + if(index > -1) { + //remove from loopingInstances list + _loopingInstancesIntervalCache.splice(index, 1); + _loopingInstances.splice(index, 1); + + //correct update loop behavior + if (_loopingInstances.length === 0 && _loopIsActive) { + _loopIsActive = false; + globals.autoUpdateLoop = _loopIsActive; + if(_loopID !== undefined) { + compatibility.cAF()(_loopID); + _loopID = -1; + } + } + } + }; } /** - * Gets the element which is used to measure the content size. - * @returns {*} TextareaCover if target element is textarea else the ContentElement. + * 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 globals + * @param autoUpdateLoop + * @returns {*} + * @constructor */ - function getContentMeasureElement() { - return _isTextarea ? _textareaCoverElement[0] : _contentElement[0]; - } - - /** - * 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. - */ - function update(hostSizeChanged, contentSizeChanged, force) { - var now = compatibility.now(); - var swallow = _swallowUpdateLag > 0 && _initialized && (now - _lastUpdateTime) < _swallowUpdateLag && (!_heightAutoCache && !_widthAutoCache); - clearTimeout(_swallowedUpdateTimeout); - if (swallow) { - _swallowedUpdateParams.h = hostSizeChanged; - _swallowedUpdateParams.c = contentSizeChanged; - _swallowedUpdateParams.f = force; - _swallowedUpdateTimeout = setTimeout(update, _swallowUpdateLag); - } - - //abort update due to: - //swallowing - //sleeping - //host is hidden or has false display - if (swallow || _isSleeping || (_initialized && !force && _hostElement.is(':hidden')) || _hostElement.css('display') === 'inline') + function OverlayScrollbarsInstance(pluginTargetElement, options, globals, autoUpdateLoop) { + //if passed element is no HTML element: skip and return + if(!isHTMLElement(pluginTargetElement)) 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 arent 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 = helper.extend(true, {}, globals.nativeScrollbarSize); + //if passed element is already initialized: set passed options if there are any and return its instance + if(instances.has(pluginTargetElement)) { + var inst = instances.get(pluginTargetElement); + inst.options(options); + return inst; } - // 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 - }; + //make correct instanceof + var _base = new window[PLUGINNAME](); - freezeResizeObserver(_sizeObserverElement); - freezeResizeObserver(_sizeAutoObserverElement); + //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; - //save current scroll offset - var currScroll = { - l: _viewportElement[_strScrollLeft](), - t: _viewportElement[_strScrollTop]() - }; - var currentPreparedOptionsCallbacks = _currentPreparedOptions.callbacks; - var currentPreparedOptionsScrollbars = _currentPreparedOptions.scrollbars; - var currentPreparedOptionsTextarea = _currentPreparedOptions.textarea; + //general readonly: + var _initialized; + var _destroyed; + var _isTextarea; + var _isBody; - //callbacks - var onUpdated = currentPreparedOptionsCallbacks.onUpdated; - var onOverflowChanged = currentPreparedOptionsCallbacks.onOverflowChanged; - var onOverflowAmountChanged = currentPreparedOptionsCallbacks.onOverflowAmountChanged; - var onDirectionChanged = currentPreparedOptionsCallbacks.onDirectionChanged; - var onContentSizeChanged = currentPreparedOptionsCallbacks.onContentSizeChanged; - var onHostSizeChanged = currentPreparedOptionsCallbacks.onHostSizeChanged; + //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 = { }; - //scrollbars visibility: - var scrollbarsVisibility = currentPreparedOptionsScrollbars.visibility; - var scrollbarsVisibilityChanged = checkCacheSingle(scrollbarsVisibility, _scrollbarsVisibilityCache, force); + //scroll + var _scrollStopDelay = 175; + var _scrollStopTimeoutId; - //scrollbars autoHide: - var scrollbarsAutoHide = currentPreparedOptionsScrollbars.autoHide; - var scrollbarsAutoHideChanged = checkCacheSingle(scrollbarsAutoHide, _scrollbarsAutoHideCache, force); + //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'; + 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__'; - //scrollbars click scrolling - var scrollbarsClickScrolling = currentPreparedOptionsScrollbars.clickScrolling; - var scrollbarsClickScrollingChanged = checkCacheSingle(scrollbarsClickScrolling, _scrollbarsClickScrollingCache, force); + //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'; - //scrollbars drag scrolling - var scrollbarsDragScrolling = currentPreparedOptionsScrollbars.dragScrolling; - var scrollbarsDragScrollingChanged = checkCacheSingle(scrollbarsDragScrolling, _scrollbarsDragScrollingCache, force); + //options: + var _defaultOptions; + var _currentOptions; + var _currentPreparedOptions; - //className - var className = _currentPreparedOptions.className; - var classNameChanged = checkCacheSingle(className, _classNameCache, force); + //update + var _lastUpdateTime; + var _swallowedUpdateParams = { }; + var _swallowedUpdateTimeout; + var _swallowUpdateLag = 33; + var _imgs = [ ]; + + //DOM elements: + var _windowElement; + var _documentElement; + var _htmlElement; + var _bodyElement; + var _targetElement; //the target element of this hide scrollbars object + var _hostElement; //the host element of this hide scrollbars 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; + + //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 resize = _currentPreparedOptions.resize; - var resizeChanged = checkCacheSingle(resize, _resizeCache, force) && !_isBody; //body can't be resized since the window itself acts as resize possibility. + var _resizeReconnectMutationObserver; + var _resizeNone; + var _resizeBoth; + var _resizeHorizontal; + var _resizeVertical; + var _resizeDragStartPosition = { }; + var _resizeDragStartSize = { }; - //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); + //==== Add / Remove Passive Event Listener ====// - //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, textareaDynHeight); - - //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 = helper.extend(true, {}, overflowBehavior); - _textareaDynWidthCache = textareaDynWidth; - _textareaDynHeightCache = textareaDynHeight; - - //set correct class name to the host element - if (classNameChanged) { - _hostElement.removeClass(_oldClassName).removeClass(_classNameThemeNone); - if (className !== undefined && className !== null && className.length > 0) - _hostElement.addClass(className); - else - _hostElement.addClass(_classNameThemeNone); + /** + * 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}); } - //set correct auto Update - if (autoUpdateChanged) { - if (autoUpdate === true) { - mutationObserversDisconnect(); - autoUpdateLoop.add(_base); + /** + * 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); + } + + + //==== 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 (autoUpdate === null) { - if (_autoUpdateRecommended) { + 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 = helper(observerElement[strChildNodes][1]); + var expandElement = helper(observerElement[strChildNodes][0]); + var expandElementChild = helper(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)); + + helper(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 !== false; + 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().first().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).first()); + } + } + + /** + * 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).first(); + 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).first().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) + 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) { + var optionsCallbacks = _currentPreparedOptions.callbacks; + + if (_isSleeping) + return; + + if (_scrollStopTimeoutId !== undefined) + clearTimeout(_scrollStopTimeoutId); + else { + if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) + refreshScrollbarsAutoHide(true); + + if (!nativeOverlayScrollbarsAreActive()) + _hostElement.addClass(_classNameHostScrolling); + + callCallback(optionsCallbacks.onScrollStart, event); + } + + refreshScrollbarHandleOffset(true, _viewportElement[_strScrollLeft]()); + refreshScrollbarHandleOffset(false, _viewportElement[_strScrollTop]()); + callCallback(optionsCallbacks.onScroll, event); + + _scrollStopTimeoutId = setTimeout(function () { + viewportOnScrollStop(); + callCallback(optionsCallbacks.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()) + _hostElement.removeClass(_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 (helper.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 = helper.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 () { + 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); + + _bodyElement.addClass(_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); + + _bodyElement.removeClass(_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 = parseIntToZeroOrNumber(_contentArrangeElement.css(_strMinMinus + _strWidth)); + bodyMinSize.h = parseIntToZeroOrNumber(_contentArrangeElement.css(_strMinMinus + _strHeight)); + bodyMinSize.c = checkCacheDouble(bodyMinSize, _bodyMinSizeCache); + bodyMinSize.f = true; //flag for "measured at least once" + } + _bodyMinSizeCache = bodyMinSize; + return bodyMinSize.c; + } + + /** + * 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 = helper.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 textareaValueLength = _isTextarea && _widthAutoCache && !_textareaAutoWrappingCache ? _targetElement.val().length : 0; + var float; + var setCSS = !_mutationObserverConnected && _widthAutoCache && !_isTextarea; + var css = {}; + 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) || bodyMinSizeC; + _contentElementScrollSizeChangeDetectedCache = contentElementScrollSize; + + return changed; + } + + /** + * 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 affectingPropsX = [ + _strWidth, + _strMinMinus + _strWidth, + _strMaxMinus + _strWidth, + _strMarginMinus + _strLeft, + _strMarginMinus + _strRight, + _strLeft, + _strRight, + 'font-weight', + 'word-spacing' + ]; + 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' + ]; + 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. + */ + function update(hostSizeChanged, contentSizeChanged, force) { + var now = compatibility.now(); + var swallow = _swallowUpdateLag > 0 && _initialized && (now - _lastUpdateTime) < _swallowUpdateLag && (!_heightAutoCache && !_widthAutoCache); + clearTimeout(_swallowedUpdateTimeout); + if (swallow) { + _swallowedUpdateParams.h = hostSizeChanged; + _swallowedUpdateParams.c = contentSizeChanged; + _swallowedUpdateParams.f = force; + _swallowedUpdateTimeout = setTimeout(update, _swallowUpdateLag); + } + + //abort update due to: + //swallowing + //sleeping + //host is hidden or has false display + if (swallow || _isSleeping || (_initialized && !force && _hostElement.is(':hidden')) || _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 currentPreparedOptionsCallbacks = _currentPreparedOptions.callbacks; + var currentPreparedOptionsScrollbars = _currentPreparedOptions.scrollbars; + var currentPreparedOptionsTextarea = _currentPreparedOptions.textarea; + + //callbacks + var onUpdated = currentPreparedOptionsCallbacks.onUpdated; + var onOverflowChanged = currentPreparedOptionsCallbacks.onOverflowChanged; + var onOverflowAmountChanged = currentPreparedOptionsCallbacks.onOverflowAmountChanged; + var onDirectionChanged = currentPreparedOptionsCallbacks.onDirectionChanged; + var onContentSizeChanged = currentPreparedOptionsCallbacks.onContentSizeChanged; + var onHostSizeChanged = currentPreparedOptionsCallbacks.onHostSizeChanged; + + //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, textareaDynHeight); + + //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; + + //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(); } } - else { - autoUpdateLoop.remove(_base); - mutationObserversConnect(); - } - } - //activate or deactivate size auto capability - if (sizeAutoCapableChanged) { - if (sizeAutoCapable) { - if (_contentGlueElement === undefined) { - _contentGlueElement = helper(_strDivBegin + _classNameContentGlueElement + _strDivEnd); - _paddingElement.before(_contentGlueElement); - } - if (_sizeAutoObserverAdded) { - _sizeAutoObserverElement.show(); + //activate or deactivate size auto capability + if (sizeAutoCapableChanged) { + if (sizeAutoCapable) { + if (_contentGlueElement === undefined) { + _contentGlueElement = helper(generateDiv(_classNameContentGlueElement)); + _paddingElement.before(_contentGlueElement); + } + if (_sizeAutoObserverAdded) { + _sizeAutoObserverElement.show(); + } + else { + _sizeAutoObserverElement = helper(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 { - _sizeAutoObserverElement = helper(_strDivBegin + _classNameSizeAutoObserverElement + _strDivEnd); - _contentGlueElement.before(_sizeAutoObserverElement); - var oldSize = {w: -1, h: -1}; - addResizeObserver(_sizeAutoObserverElement, function () { - var newSize = { - w: _sizeAutoObserverElement[0][WORDING.oW], - h: _sizeAutoObserverElement[0][WORDING.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)'); + if (_sizeAutoObserverAdded) + _sizeAutoObserverElement.hide(); } } - else { + + //if force, update all resizeObservers too + if (force) { + _sizeObserverElement.find('*').trigger(_strScroll); if (_sizeAutoObserverAdded) - _sizeAutoObserverElement.hide(); + _sizeAutoObserverElement.find('*').trigger(_strScroll); } - } - //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 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 box-sizing: - var boxSizing = _hostElement.css('box-sizing'); - var boxSizingChanged = checkCacheSingle(boxSizing, _cssBoxSizingCache, force); + //detect padding: + var padding = { + c: force, + t: parseIntToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strTop)), + r: parseIntToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strRight)), + b: parseIntToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strBottom)), + l: parseIntToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strLeft)) + }; - //detect padding: - var padding = { - c: force, - t: parseIntToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strTop)), - r: parseIntToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strRight)), - b: parseIntToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strBottom)), - l: parseIntToZeroOrNumber(_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; + } - //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]; - _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); - //detect width auto: - var widthAutoResizeDetection = false; - var widthAutoObserverDetection = (_sizeAutoObserverAdded && (_hostElement.css(_strFloat) !== 'none' /*|| _isTextarea */)) ? (Math.round(sizeAutoObserverElementBCRect.right - sizeAutoObserverElementBCRect.left) === 0) && (!paddingAbsolute ? (hostElement[WORDING.cW] - _paddingX) > 0 : true) : false; - if (sizeAutoCapable && !widthAutoObserverDetection) { - var tmpCurrHostWidth = hostElement[WORDING.oW]; - var tmpCurrContentGlueWidth = _contentGlueElement.css(_strWidth); - _contentGlueElement.css(_strWidth, _strAuto); - - var tmpNewHostWidth = hostElement[WORDING.oW]; - _contentGlueElement.css(_strWidth, tmpCurrContentGlueWidth); - widthAutoResizeDetection = tmpCurrHostWidth !== tmpNewHostWidth; - if (!widthAutoResizeDetection) { - _contentGlueElement.css(_strWidth, tmpCurrHostWidth + 1); - tmpNewHostWidth = hostElement[WORDING.oW]; + var tmpNewHostWidth = hostElement[LEXICON.oW]; _contentGlueElement.css(_strWidth, tmpCurrContentGlueWidth); widthAutoResizeDetection = tmpCurrHostWidth !== tmpNewHostWidth; - } - } - var widthAuto = (widthAutoObserverDetection || widthAutoResizeDetection) && sizeAutoCapable; - var widthAutoChanged = checkCacheSingle(widthAuto, _widthAutoCache, force); - var wasWidthAuto = !widthAuto && _widthAutoCache; - - //detect height auto: - var heightAuto = _sizeAutoObserverAdded ? (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 ? parseIntToZeroOrNumber(_hostElement.css(_strBorderMinus + _strTop + strMinusWidth)) : 0, - r: updateBorderX ? parseIntToZeroOrNumber(_hostElement.css(_strBorderMinus + _strRight + strMinusWidth)) : 0, - b: updateBorderY ? parseIntToZeroOrNumber(_hostElement.css(_strBorderMinus + _strBottom + strMinusWidth)) : 0, - l: updateBorderX ? parseIntToZeroOrNumber(_hostElement.css(_strBorderMinus + _strLeft + strMinusWidth)) : 0 - }; - - //detect margin: - var margin = { - c: force, - t: parseIntToZeroOrNumber(_hostElement.css(_strMarginMinus + _strTop)), - r: parseIntToZeroOrNumber(_hostElement.css(_strMarginMinus + _strRight)), - b: parseIntToZeroOrNumber(_hostElement.css(_strMarginMinus + _strBottom)), - l: parseIntToZeroOrNumber(_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 = { }; - - //set info for padding - _paddingX = padding.l + padding.r; - _paddingY = padding.t + padding.b; - 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 = parseIntToZeroOrNumber(cssMaxValue.h); //ih = integer height - cssMaxValue.iw = parseIntToZeroOrNumber(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 = { - w: paddingElement[WORDING.oW], - h: paddingElement[WORDING.oH] - }; - - //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 - (paddingAbsolute ? _paddingY : 0) + - (_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 - (paddingAbsolute ? _paddingX : 0) + - (_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][WORDING.cH]; - } - if (sizeAutoCapable) - _contentGlueElement.css(contentGlueElementCSS); - _contentElement.css(contentElementCSS); - - - //CHECKPOINT HERE ~ - contentElementCSS = {}; - contentGlueElementCSS = {}; - _hasOverflowCache = _hasOverflowCache || {x: false, y: false}; - - //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 || paddingAbsoluteChanged || textareaDynWidthChanged || textareaDynHeightChanged || 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 //it must be hidden if height is auto - : 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[WORDING.cW], - h: contentMeasureElement[WORDING.cH] - }; - var scrollSize = { - w: Math.max(contentMeasureElement[WORDING.sW], contentMeasureElementGuaranty[WORDING.sW]), - h: Math.max(contentMeasureElement[WORDING.sH], contentMeasureElementGuaranty[WORDING.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 - viewportElementResetCSS[_strBottom] = wasHeightAuto ? _strEmpty : resetBottomTmp; - viewportElementResetCSS[isRTLLeft] = wasWidthAuto ? _strEmpty : resetXTmp; - _viewportElement.css(viewportElementResetCSS); - - //measure and correct several sizes - //has to be clientSize because offsetSize respect borders. - var hostSize = { - w: hostElement[WORDING.cW], - h: hostElement[WORDING.cH] - }; - var contentGlueSize = { - w: Math.max(contentClientSize.w + (paddingAbsolute ? _paddingX : 0), hostSize.w - _paddingX) - (textareaDynWidth ? (_isTextarea && widthAuto ? _marginX + (!_isBorderBox ? _paddingX + _borderX : 0) : 0) : 0), - h: Math.max(contentClientSize.h + (paddingAbsolute ? _paddingY : 0), 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; + if (!widthAutoResizeDetection) { + _contentGlueElement.css(_strWidth, tmpCurrHostWidth + 1); + tmpNewHostWidth = hostElement[LEXICON.oW]; + _contentGlueElement.css(_strWidth, tmpCurrContentGlueWidth); + widthAutoResizeDetection = tmpCurrHostWidth !== tmpNewHostWidth; } + } + var widthAuto = (widthAutoObserverDetection || widthAutoResizeDetection) && sizeAutoCapable; + var widthAutoChanged = checkCacheSingle(widthAuto, _widthAutoCache, force); + var wasWidthAuto = !widthAuto && _widthAutoCache; - var maxWidth = contentGlueElementCSS[_strWidth] + (_isBorderBox ? _borderX : -_paddingX); - var maxHeight = contentGlueElementCSS[_strHeight] + (_isBorderBox ? _borderY : -_paddingX); - var textareaCoverCSS = {}; + //detect height auto: + var heightAuto = _sizeAutoObserverAdded ? (Math.round(sizeAutoObserverElementBCRect.bottom - sizeAutoObserverElementBCRect.top) === 0) /* && (!paddingAbsolute && (_msieVersion > 9 || !_msieVersion) ? true : true) */ : false; + var heightAutoChanged = checkCacheSingle(heightAuto, _heightAutoCache, force); + var wasHeightAuto = !heightAuto && _heightAutoCache; - //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; + //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 ? parseIntToZeroOrNumber(_hostElement.css(_strBorderMinus + _strTop + strMinusWidth)) : 0, + r: updateBorderX ? parseIntToZeroOrNumber(_hostElement.css(_strBorderMinus + _strRight + strMinusWidth)) : 0, + b: updateBorderY ? parseIntToZeroOrNumber(_hostElement.css(_strBorderMinus + _strBottom + strMinusWidth)) : 0, + l: updateBorderX ? parseIntToZeroOrNumber(_hostElement.css(_strBorderMinus + _strLeft + strMinusWidth)) : 0 + }; - //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; + //detect margin: + var margin = { + c: force, + t: parseIntToZeroOrNumber(_hostElement.css(_strMarginMinus + _strTop)), + r: parseIntToZeroOrNumber(_hostElement.css(_strMarginMinus + _strRight)), + b: parseIntToZeroOrNumber(_hostElement.css(_strMarginMinus + _strBottom)), + l: parseIntToZeroOrNumber(_hostElement.css(_strMarginMinus + _strLeft)) + }; - //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) { + //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 = { }; + + //set info for padding + _paddingX = padding.l + padding.r; + _paddingY = padding.t + padding.b; + 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 = parseIntToZeroOrNumber(cssMaxValue.h); //ih = integer height + cssMaxValue.iw = parseIntToZeroOrNumber(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) - textareaCoverCSS[_strWidth] = parseIntToZeroOrNumber(_textareaCoverElement.css(_strWidth)) - 1; - contentGlueElementCSS[_strWidth] -= 1; + setTopRightBottomLeft(textareaCSS, _strPaddingMinus); + else + setTopRightBottomLeft(contentElementCSS, _strPaddingMinus); } - if (heightAuto && (clientSize.h < _viewportSize.h || _isTextarea) && _paddingY === 0) { + else { + setTopRightBottomLeft(paddingElementCSS, _strEmpty); if (_isTextarea) - textareaCoverCSS[_strHeight] = parseIntToZeroOrNumber(_textareaCoverElement.css(_strHeight)) - 1; - contentGlueElementCSS[_strHeight] -= 1; + setTopRightBottomLeft(textareaCSS, _strPaddingMinus, [padding.t, padding.r, padding.b, padding.l]); + else + setTopRightBottomLeft(contentElementCSS, _strPaddingMinus, [padding.t, padding.r, padding.b, padding.l]); } - - //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); + _paddingElement.css(paddingElementCSS); + _targetElement.css(textareaCSS); } - 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 contentScrollSize = { - w: Math.max(contentMeasureElement[WORDING.sW], contentMeasureElementGuaranty[WORDING.sW]), - h: Math.max(contentMeasureElement[WORDING.sH], contentMeasureElementGuaranty[WORDING.sH]) - }; - if(hideOverflow4CorrectMeasuring) - _contentElement.css(strOverflow, _strEmpty); - if (contentBCRect.width !== undefined) { - var contentBCRectW = contentBCRect.width; - var contentBCRectH = contentBCRect.height; - var contentBCRectMargin = 0.001; - contentScrollSize.w += parseIntToZeroOrNumber(contentBCRectW + contentBCRectMargin) - contentBCRectW; - contentScrollSize.h += parseIntToZeroOrNumber(contentBCRectH + contentBCRectMargin) - contentBCRectH; - } - contentScrollSize.c = contentSizeChanged = checkCacheDouble(contentScrollSize, _contentScrollSizeCache, force); - _contentScrollSizeCache = contentScrollSize; - - //has to be clientSize because offsetSize respect borders. - hostSize = { - w: hostElement[WORDING.cW], - h: hostElement[WORDING.cH] - }; - hostSizeChanged = checkCacheDouble(hostSize, _hostSizeCache); - _hostSizeCache = hostSize; //viewport size is padding container because it never has padding, margin and a border. _viewportSize = { - w: paddingElement[WORDING.oW], - h: paddingElement[WORDING.oH] + w: paddingElement[LEXICON.oW], + h: paddingElement[LEXICON.oH] }; - 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 overflowBehaviorIsH = { - * x : overflowBehavior.x === 'h', - * y : overflowBehavior.y === 'h' - * }; - */ - var overflowAmount = { - x: Math.max(0, Math.round((contentScrollSize.w - hostSize.w + (paddingAbsolute ? _paddingX : 0)) * 100) / 100), - y: Math.max(0, Math.round((contentScrollSize.h - hostSize.h + (paddingAbsolute ? _paddingY : 0)) * 100) / 100) - }; - var hideOverflowForceTextarea = _isTextarea && (_viewportSize.w === 0 || _viewportSize.h === 0); - if (hideOverflowForceTextarea) { - overflowAmount.x = 0; - overflowAmount.y = 0; + //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 - (paddingAbsolute ? _paddingY : 0) + + (_isBorderBox ? -_borderY : _paddingY)) : _strEmpty); + contentElementCSS[_strHeight] = _strAuto; + } else if (heightAutoChanged || paddingAbsoluteChanged) { + contentElementCSS[_strMaxMinus + _strHeight] = _strEmpty; + contentElementCSS[_strHeight] = _strHundredPercent; } - 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 arrangeChanged = force; - var arrangeContent = {}; - 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) { - var borderDesign = 'px solid transparent'; - contentElementCSS[_strBorderMinus + isRTLRight] = _strEmpty; - contentElementCSS[_strMarginMinus + isRTLRight] = _strEmpty; - if (_nativeScrollbarIsOverlaid.x && hasOverflow.x && hideOverflow.xs) { - if (heightAuto) - contentElementCSS[_strMarginMinus + _strBottom] = ignoreOverlayScrollbarHiding ? _strEmpty : _overlayScrollbarDummySize.x; - if (!heightAuto && !ignoreOverlayScrollbarHiding) - contentElementCSS[_strBorderMinus + _strBottom] = _overlayScrollbarDummySize.x + borderDesign; - else - contentElementCSS[_strBorderMinus + _strBottom] = _strEmpty; - } - else { - arrangeContent.h = _strEmpty; - arrangeChanged = true; - contentElementCSS[_strBorderMinus + _strBottom] = _strEmpty; - contentElementCSS[_strMarginMinus + _strBottom] = _strEmpty; - } - if (_nativeScrollbarIsOverlaid.y && hasOverflow.y && hideOverflow.ys) { - if (widthAuto) - contentElementCSS[_strMarginMinus + isRTLLeft] = ignoreOverlayScrollbarHiding ? _strEmpty : _overlayScrollbarDummySize.y; - if (/* !widthAuto && */ !ignoreOverlayScrollbarHiding) - contentElementCSS[_strBorderMinus + isRTLLeft] = _overlayScrollbarDummySize.y + borderDesign; - else - contentElementCSS[_strBorderMinus + isRTLLeft] = _strEmpty; - } - else { - arrangeContent.w = _strEmpty; - arrangeChanged = true; - contentElementCSS[_strBorderMinus + isRTLLeft] = _strEmpty; - contentElementCSS[_strMarginMinus + isRTLLeft] = _strEmpty; - } - } - if (ignoreOverlayScrollbarHiding) { - arrangeContent.w = _strEmpty; - arrangeContent.h = _strEmpty; - arrangeChanged = true; - } - if (arrangeChanged) { - var contentArrangeElementCSS = {}; - contentArrangeElementCSS[_strWidth] = hideOverflow.y ? arrangeContent.w : _strEmpty; - contentArrangeElementCSS[_strHeight] = hideOverflow.x ? arrangeContent.h : _strEmpty; - - if (_contentArrangeElement === undefined) { - _contentArrangeElement = helper(_strDivBegin + _classNameContentArrangeElement + _strDivEnd); - _viewportElement.prepend(_contentArrangeElement); - } - _contentArrangeElement.css(contentArrangeElementCSS); - } - _contentElement.css(contentElementCSS); + if (widthAuto && (widthAutoChanged || paddingAbsoluteChanged || boxSizingChanged || cssMaxValue.c || padding.c || border.c || cssDirectionChanged)) { + if (cssMaxValue.cw) + contentElementCSS[_strMaxMinus + _strWidth] = + (cssMaxValue.cw ? (cssMaxValue.iw - (paddingAbsolute ? _paddingX : 0) + + (_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; - 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] = _strEmpty; - viewportElementCSS[_strMarginMinus + _strTop] = _strEmpty; - - viewportElementCSS[_strPaddingMinus + isRTLRight] = _strEmpty; - viewportElementCSS[_strMarginMinus + isRTLRight] = _strEmpty; - } - viewportElementCSS[_strPaddingMinus + isRTLLeft] = _strEmpty; - 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] = strHidden; - paddingElementCSS[strOverflowY] = strHidden; - } - } - else { - if (!clipAlways || (overflowBehaviorIsVH.x || overflowBehaviorIsVS.x || overflowBehaviorIsVH.y || overflowBehaviorIsVS.y)) { - //only un-hide if Textarea - if (_isTextarea) { - paddingElementCSS[strOverflowX] = _strEmpty; - paddingElementCSS[strOverflowY] = _strEmpty; - } - viewportElementCSS[strOverflowX] = strVisible; - 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.style; - elementStyle.webkitTransform = 'scale(1)'; - elementStyle.display = 'run-in'; - var dump = element[WORDING.oH]; - elementStyle.display = _strEmpty; - elementStyle.webkitTransform = _strEmpty; - } - //force hard redraw in webkit if native overlaid scrollbars shall appear - if (ignoreOverlayScrollbarHidingChanged && ignoreOverlayScrollbarHiding) { - _hostElement.hide(); - var dump = hostElement[WORDING.oH]; - _hostElement.show(); - } + contentElementCSS[_strWidth] = _strAuto; + contentElementCSS[_strFloat] = isRTLRight; } - - //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; - } + 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); - //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); + //CHECKPOINT HERE ~ + contentElementCSS = {}; + contentGlueElementCSS = {}; + _hasOverflowCache = _hasOverflowCache || {x: false, y: false}; - //add or remove rtl class name for styling purposes - if (cssDirectionChanged) { - if (_isRTL) - _hostElement.addClass(_classNameHostRTL); - else - _hostElement.removeClass(_classNameHostRTL); - } + //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 || paddingAbsoluteChanged || textareaDynWidthChanged || textareaDynHeightChanged || 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 //it must be hidden if height is auto + : heightAuto; //if there is not the restricted Measuring bug, it must be hidden if the height is auto - //manage the resize feature (CSS3 resize "polyfill" for this plugin) - if (_isBody) - _hostElement.addClass(_classNameHostResizeDisabled); - if (resizeChanged) { - var addCornerEvents = function () { - _scrollbarCornerElement.on(_strMouseTouchDownEvent, scrollbarCornerOnMouseDown); + //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 removeCornerEvents = function () { - _scrollbarCornerElement.off(_strMouseTouchDownEvent, scrollbarCornerOnMouseDown); + var scrollSize = { + w: Math.max(contentMeasureElement[LEXICON.sW], contentMeasureElementGuaranty[LEXICON.sW]), + h: Math.max(contentMeasureElement[LEXICON.sH], contentMeasureElementGuaranty[LEXICON.sH]) }; - if (_resizeNone) { - _hostElement.addClass(_classNameHostResizeDisabled); - _scrollbarCornerElement.removeClass(_classNameScrollbarCornerResize) - .removeClass(_classNameScrollbarCornerResizeB) - .removeClass(_classNameScrollbarCornerResizeH) - .removeClass(_classNameScrollbarCornerResizeV); - - removeCornerEvents(); - } - else { - _hostElement.removeClass(_classNameHostResizeDisabled); - _scrollbarCornerElement.addClass(_classNameScrollbarCornerResize); - if (_resizeBoth) - _scrollbarCornerElement.addClass(_classNameScrollbarCornerResizeB); - else if (_resizeHorizontal) - _scrollbarCornerElement.addClass(_classNameScrollbarCornerResizeH); - else if (_resizeVertical) - _scrollbarCornerElement.addClass(_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) { - _hostElement.removeClass(_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); - } - } + var contentClientSize = { + w: _isTextarea && textareaSize && !textareaDynWidth ? textareaSize.ow : widthAuto ? clientSize.w : scrollSize.w, + h: _isTextarea && textareaSize && !textareaDynHeight ? textareaSize.oh : heightAuto ? clientSize.h : scrollSize.h }; - 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); - } + + //apply the correct viewport style + viewportElementResetCSS[_strBottom] = wasHeightAuto ? _strEmpty : resetBottomTmp; + viewportElementResetCSS[isRTLLeft] = wasWidthAuto ? _strEmpty : resetXTmp; + _viewportElement.css(viewportElementResetCSS); + + //measure and correct several sizes + //has to be clientSize because offsetSize respect borders. + var hostSize = { + w: hostElement[LEXICON.cW], + h: hostElement[LEXICON.cH] }; - if (_scrollbarsAutoHideLeave || _scrollbarsAutoHideMove) { - removeMouseTouchEvents(); - addMouseTouchEvents(_scrollbarsAutoHideMove); + var contentGlueSize = { + w: Math.max(contentClientSize.w + (paddingAbsolute ? _paddingX : 0), hostSize.w - _paddingX) - (textareaDynWidth ? (_isTextarea && widthAuto ? _marginX + (!_isBorderBox ? _paddingX + _borderX : 0) : 0) : 0), + h: Math.max(contentClientSize.h + (paddingAbsolute ? _paddingY : 0), 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] = parseIntToZeroOrNumber(_textareaCoverElement.css(_strWidth)) - 1; + contentGlueElementCSS[_strWidth] -= 1; + } + if (heightAuto && (clientSize.h < _viewportSize.h || _isTextarea) && _paddingY === 0) { + if (_isTextarea) + textareaCoverCSS[_strHeight] = parseIntToZeroOrNumber(_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); } - else { - removeMouseTouchEvents(); + 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 contentScrollSize = { + w: Math.max(contentMeasureElement[LEXICON.sW], contentMeasureElementGuaranty[LEXICON.sW]), + h: Math.max(contentMeasureElement[LEXICON.sH], contentMeasureElementGuaranty[LEXICON.sH]) + }; + if(hideOverflow4CorrectMeasuring) + _contentElement.css(strOverflow, _strEmpty); + if (contentBCRect.width) { + var contentBCRectW = contentBCRect.width; + var contentBCRectH = contentBCRect.height; + var contentBCRectMargin = 0.001; + contentScrollSize.w += parseIntToZeroOrNumber(contentBCRectW + contentBCRectMargin) - contentBCRectW; + contentScrollSize.h += parseIntToZeroOrNumber(contentBCRectH + contentBCRectMargin) - contentBCRectH; } + contentScrollSize.c = contentSizeChanged = checkCacheDouble(contentScrollSize, _contentScrollSizeCache, force); + _contentScrollSizeCache = contentScrollSize; - if (_scrollbarsAutoHideNever) - refreshScrollbarsAutoHide(true); - else - refreshScrollbarsAutoHide(false, true); - } + //has to be clientSize because offsetSize respect borders. + hostSize = { + w: hostElement[LEXICON.cW], + h: hostElement[LEXICON.cH] + }; + hostSizeChanged = checkCacheDouble(hostSize, _hostSizeCache); + _hostSizeCache = hostSize; - //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); - } + //viewport size is padding container because it never has padding, margin and a border. + _viewportSize = { + w: paddingElement[LEXICON.oW], + h: paddingElement[LEXICON.oH] + }; - //manage interactivity - if (scrollbarsClickScrollingChanged) - refreshScrollbarsInteractive(true, scrollbarsClickScrolling); - if (scrollbarsDragScrollingChanged) - refreshScrollbarsInteractive(false, scrollbarsDragScrolling); + 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 overflowBehaviorIsH = { + * x : overflowBehavior.x === 'h', + * y : overflowBehavior.y === 'h' + * }; + */ + var overflowAmount = { + x: Math.max(0, Math.round((contentScrollSize.w - hostSize.w + (paddingAbsolute ? _paddingX : 0)) * 100) / 100), + y: Math.max(0, Math.round((contentScrollSize.h - hostSize.h + (paddingAbsolute ? _paddingY : 0)) * 100) / 100) + }; + var hideOverflowForceTextarea = _isTextarea && (_viewportSize.w === 0 || _viewportSize.h === 0); + if (hideOverflowForceTextarea) { + overflowAmount.x = 0; + 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; - //manage class name which indicates scrollable overflow - if (hideOverflow.x || hideOverflow.y) - _hostElement.addClass(_classNameHostOverflow); - else - _hostElement.removeClass(_classNameHostOverflow); - if (hideOverflow.x) - _hostElement.addClass(_classNameHostOverflowX); - else - _hostElement.removeClass(_classNameHostOverflowX); - if (hideOverflow.y) - _hostElement.addClass(_classNameHostOverflowY); - else - _hostElement.removeClass(_classNameHostOverflowY); + 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; - //handle scroll - if (_isTextarea && contentSizeChanged) { - var textareaInfo = getTextareaInfo(); - if (textareaInfo !== undefined) { - var textareaRowsChanged = _textareaInfoCache === undefined ? true : textareaInfo.rows !== _textareaInfoCache.rows; - var widestRow = textareaInfo.wRow; - var cursorRow = textareaInfo.cursorRow; - var cursorCol = textareaInfo.cursorCol; - var lastRow = textareaInfo.rows; - var lastCol = textareaInfo.cols; - var cursorPos = textareaInfo.pos; - var cursorMax = textareaInfo.max; - 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 native scrollbar is overlay at x OR y axis, prepare DOM + if (_nativeScrollbarIsOverlaid.x || _nativeScrollbarIsOverlaid.y) { + var arrangeChanged = force; + var arrangeContent = {}; + 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; - 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. + arrangeChanged = checkCacheSingle(arrangeContent, _arrangeContentSizeCache, force); + _arrangeContentSizeCache = arrangeContent; + } + + if (hasOverflow.c || hideOverflow.c || contentScrollSize.c || cssDirectionChanged || widthAutoChanged || heightAutoChanged || widthAuto || heightAuto || ignoreOverlayScrollbarHidingChanged) { + var borderDesign = 'px solid transparent'; + contentElementCSS[_strBorderMinus + isRTLRight] = _strEmpty; + contentElementCSS[_strMarginMinus + isRTLRight] = _strEmpty; + if (_nativeScrollbarIsOverlaid.x && hasOverflow.x && hideOverflow.xs) { + if (heightAuto) + contentElementCSS[_strMarginMinus + _strBottom] = ignoreOverlayScrollbarHiding ? _strEmpty : _overlayScrollbarDummySize.x; + if (!heightAuto && !ignoreOverlayScrollbarHiding) + contentElementCSS[_strBorderMinus + _strBottom] = _overlayScrollbarDummySize.x + borderDesign; else - _viewportElement[_strScrollLeft](doScroll.x); + contentElementCSS[_strBorderMinus + _strBottom] = _strEmpty; + } + else { + arrangeContent.h = _strEmpty; + arrangeChanged = true; + contentElementCSS[_strBorderMinus + _strBottom] = _strEmpty; + contentElementCSS[_strMarginMinus + _strBottom] = _strEmpty; + } + if (_nativeScrollbarIsOverlaid.y && hasOverflow.y && hideOverflow.ys) { + if (widthAuto) + contentElementCSS[_strMarginMinus + isRTLLeft] = ignoreOverlayScrollbarHiding ? _strEmpty : _overlayScrollbarDummySize.y; + if (/* !widthAuto && */ !ignoreOverlayScrollbarHiding) + contentElementCSS[_strBorderMinus + isRTLLeft] = _overlayScrollbarDummySize.y + borderDesign; + else + contentElementCSS[_strBorderMinus + isRTLLeft] = _strEmpty; + } + else { + arrangeContent.w = _strEmpty; + arrangeChanged = true; + contentElementCSS[_strBorderMinus + isRTLLeft] = _strEmpty; + contentElementCSS[_strMarginMinus + isRTLLeft] = _strEmpty; } } + if (ignoreOverlayScrollbarHiding) { + arrangeContent.w = _strEmpty; + arrangeContent.h = _strEmpty; + arrangeChanged = true; + } + if (arrangeChanged) { + var contentArrangeElementCSS = {}; + contentArrangeElementCSS[_strWidth] = hideOverflow.y ? arrangeContent.w : _strEmpty; + contentArrangeElementCSS[_strHeight] = hideOverflow.x ? arrangeContent.h : _strEmpty; + + if (_contentArrangeElement === undefined) { + _contentArrangeElement = helper(generateDiv(_classNameContentArrangeElement)); + _viewportElement.prepend(_contentArrangeElement); + } + _contentArrangeElement.css(contentArrangeElementCSS); + } + _contentElement.css(contentElementCSS); } - _textareaInfoCache = textareaInfo; - } - else if (!_isTextarea) { - if (_isRTL && _rtlScrollBehavior.i && _nativeScrollbarIsOverlaid.y && hasOverflow.x && _normalizeRTLCache) - currScroll.l += _contentBorderSize.w; - _viewportElement[_strScrollLeft](currScroll.l); - _viewportElement[_strScrollTop](currScroll.t); - } - if (cssDirectionChanged && helper.isFunction(onDirectionChanged)) { - callCallback(onDirectionChanged, { - isRTL: _isRTL, - dir: cssDirection - }); - } - if (hostSizeChanged && helper.isFunction(onHostSizeChanged)) { - callCallback(onHostSizeChanged, { - width: _hostSizeCache.w, - height: _hostSizeCache.h - }); - } - if (contentSizeChanged && helper.isFunction(onContentSizeChanged)) { - callCallback(onContentSizeChanged, { - width: _contentScrollSizeCache.w, - height: _contentScrollSizeCache.h - }); - } - if ((hasOverflow.c || hideOverflow.c) && helper.isFunction(onOverflowChanged)) { - callCallback(onOverflowChanged, { - x: hasOverflow.x, - y: hasOverflow.y, - xScrollable: hideOverflow.xs, - yScrollable: hideOverflow.ys, - clipped: hideOverflow.x || hideOverflow.y - }); - } - if (overflowAmount.c && helper.isFunction(onOverflowAmountChanged)) { - callCallback(onOverflowAmountChanged, { - x: overflowAmount.x, - y: overflowAmount.y - }); - } - } + 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(); + } - //fix body min size - if (_isBody && (hasOverflow.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 && hasOverflow.x) - _contentElement.css(_strMinMinus + _strWidth, _bodyMinSizeCache.w + _overlayScrollbarDummySize.y); - if (_nativeScrollbarIsOverlaid.x && hasOverflow.y) - _contentElement.css(_strMinMinus + _strHeight, _bodyMinSizeCache.h + _overlayScrollbarDummySize.x); - _bodyMinSizeCache.c = false; - } - unfreezeResizeObserver(_sizeObserverElement); - unfreezeResizeObserver(_sizeAutoObserverElement); + // 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; - if (helper.isFunction(onUpdated)) { - callCallback(onUpdated, { - forced: force - }); - } - } + viewportElementCSS[_strPaddingMinus + isRTLRight] = _nativeScrollbarMinSize.y; + viewportElementCSS[_strMarginMinus + isRTLRight] = -_nativeScrollbarMinSize.y; + } + else { + viewportElementCSS[_strPaddingMinus + _strTop] = _strEmpty; + viewportElementCSS[_strMarginMinus + _strTop] = _strEmpty; - /** - * 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; - }; + viewportElementCSS[_strPaddingMinus + isRTLRight] = _strEmpty; + viewportElementCSS[_strMarginMinus + isRTLRight] = _strEmpty; + } + viewportElementCSS[_strPaddingMinus + isRTLLeft] = _strEmpty; + viewportElementCSS[_strMarginMinus + isRTLLeft] = _strEmpty; - /** - * 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" 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 isZoom = force === 'zoom'; - var imgElementSelector = 'img'; - var imgElementLoadEvent = 'load'; - if (force === _strAuto) { - attrsChanged = meaningfulAttrsChanged(); - contentSizeC = updateAutoContentSizeChanged(); - if (attrsChanged || contentSizeC) - update(false, contentSizeC); - } - else if (isZoom) { - update(true, true); - } - else { - force = _isSleeping || force; - _isSleeping = false; - update(false, false, force); - } - if(!_isTextarea && !isZoom) { - _contentElement.find(imgElementSelector).each(function(i, el) { - var index = helper.inArray(el, _imgs); - if (index === -1) { - el = helper(el); - el.off(imgElementLoadEvent, onImgLoad).on(imgElementLoadEvent, onImgLoad); + //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] = strHidden; + paddingElementCSS[strOverflowY] = strHidden; + } + } + else { + if (!clipAlways || (overflowBehaviorIsVH.x || overflowBehaviorIsVS.x || overflowBehaviorIsVH.y || overflowBehaviorIsVS.y)) { + //only un-hide if Textarea + if (_isTextarea) { + paddingElementCSS[strOverflowX] = _strEmpty; + paddingElementCSS[strOverflowY] = _strEmpty; + } + viewportElementCSS[strOverflowX] = strVisible; + 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.style; + elementStyle.webkitTransform = 'scale(1)'; + elementStyle.display = 'run-in'; + var dump = element[LEXICON.oH]; + elementStyle.display = _strEmpty; + 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(); + } } - }); - } - }; - /** - 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 (helper.isEmptyObject(newOptions) || !helper.isPlainObject(newOptions)) { - if (helper.type(newOptions) === TYPES.s) { - if (arguments.length >= 2) { - var option = {}; - byPropertyPath.set(option, newOptions, value, true); - setOptions(option); - update(); - return; + //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); + + //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); + } + } + }; + 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); + + //manage class name which indicates scrollable overflow + if (hideOverflow.x || hideOverflow.y) + addClass(_hostElement, _classNameHostOverflow); else - return byPropertyPath.get(_currentOptions, newOptions); + removeClass(_hostElement, _classNameHostOverflow); + if (hideOverflow.x) + addClass(_hostElement, _classNameHostOverflowX); + else + removeClass(_hostElement, _classNameHostOverflowX); + if (hideOverflow.y) + addClass(_hostElement, _classNameHostOverflowY); + else + removeClass(_hostElement, _classNameHostOverflowY); + + //handle scroll + if (_isTextarea && contentSizeChanged) { + var textareaInfo = getTextareaInfo(); + if (textareaInfo !== undefined) { + var textareaRowsChanged = _textareaInfoCache === undefined ? true : textareaInfo.rows !== _textareaInfoCache.rows; + var widestRow = textareaInfo.wRow; + var cursorRow = textareaInfo.cursorRow; + var cursorCol = textareaInfo.cursorCol; + var lastRow = textareaInfo.rows; + var lastCol = textareaInfo.cols; + var cursorPos = textareaInfo.pos; + var cursorMax = textareaInfo.max; + 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 && (hasOverflow.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 && hasOverflow.x) + _contentElement.css(_strMinMinus + _strWidth, _bodyMinSizeCache.w + _overlayScrollbarDummySize.y); + if (_nativeScrollbarIsOverlaid.x && hasOverflow.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 = helper(generateDiv(_classNameScrollbar + _strSpace + _classNameScrollbarHorizontal)); + _scrollbarHorizontalTrackElement = helper(generateDiv(_classNameScrollbarTrack)); + _scrollbarHorizontalHandleElement = helper(generateDiv(_classNameScrollbarHandle)); + _scrollbarVerticalElement = helper(generateDiv(_classNameScrollbar + _strSpace + _classNameScrollbarVertical)); + _scrollbarVerticalTrackElement = helper(generateDiv(_classNameScrollbarTrack)); + _scrollbarVerticalHandleElement = helper(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 = helper(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 mouseDownScroll; + var mouseDownOffset; + var xy = scrollbarVars.xy; + var scroll = _strScroll + scrollbarVars.LT; + var strActive = 'active'; + var trackTimeout; + var scrollDurationFactor = 1; + var increaseTrackScrollAmount = function () { + scrollDurationFactor = 0.5; + }; + var decreaseTrackScrollAmount = function () { + scrollDurationFactor = 1; + }; + var handleDragMove = function (event) { + var trackLength = scrollbarVars.i.tl; + var handleLength = scrollbarVars.i.hl; + var scrollRange = scrollbarVars.i.ms; + var scrollRaw = (handleLength / 2) + compatibility.page(event)[xy] - mouseDownOffset; + var scrollDeltaPercent = (scrollRaw - (handleLength / 2)) / (trackLength - handleLength); + var scrollDelta = (scrollRange * scrollDeltaPercent); + scrollDelta = isFinite(scrollDelta) ? scrollDelta : 0; + if (_isRTL && isHorizontal && (_rtlScrollBehavior.n || !_rtlScrollBehavior.n && !_rtlScrollBehavior.i)) + scrollDelta *= -1; + _viewportElement[scroll](mouseDownScroll + scrollDelta); + + if (!_supportPassiveEvents) + compatibility.prvD(event); + }; + var documentMouseTouchUp = function (event) { + event = event || event.originalEvent; + removeClass(_bodyElement, _classNameDragging); + removeClass(scrollbarVars.h, strActive); + removeClass(scrollbarVars.t, strActive); + removeClass(scrollbarVars.s, strActive); + + if (_supportPassiveEvents) { + removePassiveEventListener(_documentElement, _strMouseTouchMoveEvent, handleDragMove); + removePassiveEventListener(_documentElement, _strMouseTouchUpEvent, documentMouseTouchUp); + removePassiveEventListener(_documentElement, _strKeyDownEvent, documentKeyDown); + removePassiveEventListener(_documentElement, _strKeyUpEvent, documentKeyUp); + } + else { + _documentElement.off(_strMouseTouchMoveEvent, handleDragMove) + .off(_strMouseTouchUpEvent, documentMouseTouchUp) + .off(_strKeyDownEvent, documentKeyDown) + .off(_strKeyUpEvent, documentKeyUp); + } + _documentElement.off(_strSelectStartEvent, documentOnSelectStart); + + decreaseTrackScrollAmount(); + mouseDownScroll = undefined; + mouseDownOffset = undefined; + if (trackTimeout !== undefined) { + _base.scrollStop(); + clearTimeout(trackTimeout); + trackTimeout = undefined; + } + + //if mouse is outside host element + var rect = _hostElement[0].getBoundingClientRect(); + if (!(event.clientX >= rect.left && event.clientX <= rect.right && + event.clientY >= rect.top && event.clientY <= rect.bottom)) { + hostOnMouseLeave(); + } + if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) + refreshScrollbarsAutoHide(false); + }; + var documentKeyDown = function (event) { + if (event.keyCode == 16) + increaseTrackScrollAmount(); + }; + var documentKeyUp = function (event) { + if (event.keyCode == 16) + decreaseTrackScrollAmount(); + }; + scrollbarVars.h.on(_strMouseTouchDownEvent, function (event) { + if (_isSleeping) + return; + + var originalEvent = event.originalEvent || event; + var isTouchEvent = originalEvent.touches !== undefined; + if (nativeOverlayScrollbarsAreActive() || !_scrollbarsDragScrollingCache || (isTouchEvent && !_scrollbarsTouchSupport)) + return; + + if (compatibility.mBtn(event) === 1 || isTouchEvent) { + mouseDownScroll = _viewportElement[scroll](); + mouseDownScroll = mouseDownScroll === undefined ? 0 : mouseDownScroll; + if (_isRTL && isHorizontal && !_rtlScrollBehavior.n || !_isRTL) + mouseDownScroll = mouseDownScroll < 0 ? 0 : mouseDownScroll; + mouseDownOffset = compatibility.page(event)[xy]; + + + addClass(_bodyElement, _classNameDragging); + addClass(scrollbarVars.h, strActive); + addClass(scrollbarVars.s, strActive); + + if (_supportPassiveEvents) { + addPassiveEventListener(_documentElement, _strMouseTouchMoveEvent, handleDragMove); + addPassiveEventListener(_documentElement, _strMouseTouchUpEvent, documentMouseTouchUp); + } + else { + _documentElement.on(_strMouseTouchMoveEvent, handleDragMove) + .on(_strMouseTouchUpEvent, documentMouseTouchUp); + } + _documentElement.on(_strSelectStartEvent, documentOnSelectStart); + compatibility.prvD(event); + } + }); + scrollbarVars.t.on(_strMouseTouchDownEvent, function (event) { + if (_isSleeping) + return; + + var originalEvent = event.originalEvent || event; + var isTouchEvent = originalEvent.touches !== undefined; + if (nativeOverlayScrollbarsAreActive() || !_scrollbarsClickScrollingCache || (isTouchEvent && !_scrollbarsTouchSupport)) + return; + + if (compatibility.mBtn(event) === 1 || isTouchEvent) { + var scrollDistance = _viewportSize[scrollbarVars._wh]; + var trackOffset = scrollbarVars.t.offset()[scrollbarVars.lt]; + var decreaseScroll; + var isFirstIteration = true; + if (event.shiftKey) + increaseTrackScrollAmount(); + var scrollAction = function () { + var handleOffset = scrollbarVars.i.ho; + var handleLength = scrollbarVars.i.hl; + var mouseOffset = mouseDownOffset - trackOffset; + var scrollDuration = 200 * scrollDurationFactor; + var timeoutDelay = isFirstIteration ? Math.max(333, scrollDuration) : scrollDuration; + var scrollObj = {}; + var rtlIsNormal = _isRTL && isHorizontal && ((!_rtlScrollBehavior.i && !_rtlScrollBehavior.n) || _normalizeRTLCache); + var decreaseScrollCondition = handleOffset > mouseOffset; + + if (rtlIsNormal) + decreaseScrollCondition = handleOffset < mouseOffset; + + if (decreaseScrollCondition) { + if (decreaseScroll === undefined) + decreaseScroll = true; + scrollObj[scrollbarVars.xy] = '-=' + scrollDistance; + } + else { + if (decreaseScroll === undefined) + decreaseScroll = false; + scrollObj[scrollbarVars.xy] = '+=' + scrollDistance; + } + _base.scrollStop(); + _base.scroll(scrollObj, scrollDuration, 'linear'); + + var finishedCondition = decreaseScroll ? handleOffset <= mouseOffset : handleOffset + handleLength >= mouseOffset; + if (rtlIsNormal) + finishedCondition = decreaseScroll ? handleOffset + handleLength >= mouseOffset : handleOffset <= mouseOffset; + + if (finishedCondition) { + clearTimeout(trackTimeout); + _base.scrollStop(); + trackTimeout = undefined; + } + else + trackTimeout = setTimeout(scrollAction, timeoutDelay); + isFirstIteration = false; + }; + + mouseDownOffset = compatibility.page(event)[xy]; + + addClass(_bodyElement, _classNameDragging); + addClass(scrollbarVars.t, strActive); + addClass(scrollbarVars.s, strActive); + + if (_supportPassiveEvents) { + addPassiveEventListener(_documentElement, _strMouseTouchUpEvent, documentMouseTouchUp); + addPassiveEventListener(_documentElement, _strKeyDownEvent, documentKeyDown); + addPassiveEventListener(_documentElement, _strKeyUpEvent, documentKeyUp); + } + else { + _documentElement.on(_strMouseTouchUpEvent, documentMouseTouchUp) + .on(_strKeyDownEvent, documentKeyDown) + .on(_strKeyUpEvent, documentKeyUp); + } + _documentElement.on(_strSelectStartEvent, documentOnSelectStart); + + scrollAction(); + compatibility.prvD(event); + } + }).hover(function () { //make sure both scrollbars will stay visible if one scrollbar is hovered if autoHide is "scroll". + if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) { + _scrollbarsAutoHideFlagScrollAndHovered = true; + refreshScrollbarsAutoHide(true); + } + }, 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) + _hostElement.removeClass(scrollbarClassName); + else + _hostElement.addClass(scrollbarClassName); + + if (canScroll) + scrollbarElement.removeClass(_classNameScrollbarUnusable); + else + scrollbarElement.addClass(_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) + _scrollbarHorizontalElement.removeClass(_classNameScrollbarAutoHidden); + //if(_hasOverflowCache.y && _hideOverflowCache.ys) + _scrollbarVerticalElement.removeClass(_classNameScrollbarAutoHidden); + } + else { + var strActive = 'active'; + var hide = function () { + if (!_scrollbarsAutoHideFlagScrollAndHovered) { + var anyActive = _scrollbarHorizontalHandleElement.hasClass(strActive) || _scrollbarVerticalHandleElement.hasClass(strActive); + if (!anyActive && (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove || _scrollbarsAutoHideLeave)) + _scrollbarHorizontalElement.addClass(_classNameScrollbarAutoHidden); + if (!anyActive && (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove || _scrollbarsAutoHideLeave)) + _scrollbarVerticalElement.addClass(_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); + + //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 * 100000) / 100000) + "%"; //the last * 100000 / 100000 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 posRatio; + var handleLength = scrollbarVars.i.hl; + var trackLength = scrollbarVars.t[0]['offset' + scrollbarVars.WH]; + var handleTrackDiff = trackLength - handleLength; + var offset = handleTrackDiff; + + //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.n || !_rtlScrollBehavior.n && !_rtlScrollBehavior.i)) + offset = trackLength - handleLength - offset; + offset = Math.max(0, offset); + + if (_supportTransform) { + if (isRTLisHorizontal) + offset = -(trackLength - handleLength - offset); + translateValue = isHorizontal ? strTranslateBrace + offset + 'px, 0px)' : strTranslateBrace + '0px, ' + offset + 'px)'; + handleCSS['-webkit-' + strTransform] = translateValue; + handleCSS['-moz-' + strTransform] = translateValue; + handleCSS['-ms-' + strTransform] = translateValue; + handleCSS['-o-' + strTransform] = translateValue; + handleCSS[strTransform] = translateValue; } else - return _currentOptions; - } - setOptions(newOptions); - var isSleepingTmp = _isSleeping || false; - _isSleeping = false; - update(); - _isSleeping = isSleepingTmp; - }; + handleCSS[scrollbarVars.lt] = offset; + //only apply css if offset has changed and overflow exists. - /** - * 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); + if (!nativeOverlayScrollbarsAreActive()) + scrollbarVars.h.css(handleCSS); - _sizeObserverElement.remove(); - if (_contentGlueElement !== undefined) - _contentGlueElement.remove(); - if (_contentArrangeElement !== undefined) - _contentArrangeElement.remove(); - if (_sizeAutoObserverAdded) - _sizeAutoObserverElement.remove(); - - 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); + scrollbarVars.i.ho = offset; //ho = handle offset + scrollbarVars.i.tl = trackLength; //tl = track length } - _scrollbarHorizontalElement.remove(); - _scrollbarVerticalElement.remove(); - if(_scrollbarCornerElement) - _scrollbarCornerElement.remove(); - if (!_resizeNone) - scrollbarCornerOnResized(); + /** + * 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; - _contentElement.contents() - .unwrap() - .unwrap() - .unwrap(); - - if (_isBody) - _htmlElement.removeClass(_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); - } - - _textareaCoverElement.remove(); - _targetElement.removeClass(_classNameTextareaElement) - .removeClass(_classNameTextInherit) - .unwrap() - .removeAttr(WORDING.s); - _hostElement.remove(); + element1[action](className); + element2[action](className); } - else { - _targetElement.removeClass(_classNameHostElement); - _hostElement.removeClass(_classNameHostElement) - .removeClass(_classNameHostResizeDisabled) - .removeClass(_classNameHostRTL) - .removeClass(_classNameHostScrollbarHorizontalHidden) - .removeClass(_classNameHostScrollbarVerticalHidden) - .removeClass(_classNameHostTransition) - .removeClass(_classNameHostScrolling) - .removeClass(_classNameHostOverflow) - .removeClass(_classNameHostOverflowX) - .removeClass(_classNameHostOverflowY) - .removeClass(_classNameThemeNone) - .removeClass(_classNameCache); - } - - for(var i = 0; i < _imgs.length; i++) - helper(_imgs[i]).off('load', onImgLoad); - _imgs = undefined; - - instances.rem(pluginTargetElement); - var onDestroyed = _currentPreparedOptions.callbacks.onDestroyed; - if (helper.isFunction(onDestroyed)) - 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 defined, else this object isn't valid. - * axis : [string], Default value is 'xy'. - * block : [string], Default value is 'begin'. - * margin : [number, array, boolean] Default value is false. - * } - * - * Possible axis settings are: - * 'x' Scrolls only the x axis. - * 'y' Scrolls only the y axis. - * 'xy' Scrolls both axis. - * 'yx' Same as 'xy' - * - * 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 edges. - * [ string, string ] Specify Begin or End for each axis individually. - * - * Possible margin settings are: -- The actual margin of the element wont be affect, this option affects only the final scroll offset. - * true The true margin of the element will be used. - * false No margin will be used. - * [NUMBER] The margin will be used for all edges. - * [ [NUMBER], [NUMBER] ] The first margin number will be used for the margin of the X axis egdes (left and right) and the second number will be used for the Y axis edges (top and bottom). - * [ [NUMBER], [NUMBER],[NUMBER], [NUMBER] ] Each edge gets its own margin value, the first value stays for the top margin, the second for the right margin, the third for the bottom margin and the forth for the left margin. - * - * @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; + /** + * 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 { - 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 - } + 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 }; } - var coordinatesXAxisProps = [_strX, _strLeft, 'l']; - var coordinatesYAxisProps = [_strY, _strTop, 't']; - var coordinatesOperators = ['+=', '-=', '*=', '/=']; - var i; - var finalScroll = { }; - var durationIsObject = helper.type(duration) === TYPES.o; - var strEnd = 'end'; - var strBegin = 'begin'; - var strCenter = 'center'; - var strNearest = 'nearest'; - var elementObjSettings = { - axis: 'xy', - block: [strBegin, strBegin], - margin: [0, 0, 0, 0] - }; - var elementObjSettingsAxisValues = [_strX, _strY, 'xy', 'yx']; - var elementObjSettingsBlockValues = [strBegin, strEnd, strCenter, strNearest]; - var coordinatesIsElementObj = coordinates.hasOwnProperty('el'); - var possibleElement = coordinatesIsElementObj ? coordinates.el : coordinates; - var possibleElementIsJQuery = possibleElement instanceof helper || possibleElement instanceof window.jQuery; - var possibleElementIsHTMLElement = possibleElementIsJQuery ? false : isHTMLElement(possibleElement); - var checkSettingsStringValue = function (currValue, allowedValues) { - for (i = 0; i < allowedValues.length; i++) { - if (currValue === allowedValues[i]) + + //==== Utils ====// + + /** + * Calls the given callback with the given args. The Context of this callback is always _base (this). + * @param callback The callback function which shall be called. + * @param args The args with which the callback shall be called. + */ + function callCallback(callback, args) { + if(_initialized && helper.isFunction(callback)) + callback.call(_base, 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) { + return ( + typeof window.HTMLElement === TYPES.o ? o instanceof window.HTMLElement : //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; + 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 (var 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. + */ + function parseIntToZeroOrNumber(value) { + var num = 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.prop('selectionStart'); + if (textareaCursorPosition === undefined) + return; + var textareaValue = _targetElement.val(); + var textareaLength = textareaValue.length; + var textareaRowSplit = textareaValue.split("\n"); + var textareaLastRow = textareaRowSplit.length; + var textareaCurrentCursorRowSplit = textareaValue.substr(0, textareaCursorPosition).split("\n"); + var widestRow = 0; + var textareaLastCol = 0; + var cursorRow = textareaCurrentCursorRowSplit.length; + var cursorCol = textareaCurrentCursorRowSplit[textareaCurrentCursorRowSplit.length - 1].length; + var rowCols; + var i; + + //get widest Row and the last column of the textarea + for (i = 0; i < textareaRowSplit.length; i++) { + rowCols = textareaRowSplit[i].length; + if (rowCols > textareaLastCol) { + widestRow = i + 1; + textareaLastCol = rowCols; + } + } + + return { + cursorRow: cursorRow, + cursorCol: cursorCol, + rows: textareaLastRow, + cols: textareaLastCol, + wRow: widestRow, + pos: textareaCursorPosition, + max: textareaLength + }; + } + + /** + * 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; - }; - var getRawScroll = function (coordinates) { - var rawScroll = {}; - if (helper.type(coordinates) === TYPES.a && coordinates.length > 0) { - rawScroll.x = coordinates[0]; - rawScroll.y = coordinates[1]; - } - else if (helper.type(coordinates) === TYPES.s || helper.type(coordinates) === TYPES.n) { - rawScroll.x = coordinates; - rawScroll.y = coordinates; - } - else if (helper.type(coordinates) === TYPES.o) { - coordinates = helper.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.length; 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 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 && !_normalizeRTLCache; - - if (helper.type(rawScroll) === TYPES.s) { - //check operator - if (rawScroll.length > 2) { - var possibleOperator = rawScroll.substr(0, 2); - for (i = 0; i < coordinatesOperators.length; i++) { - if (possibleOperator === coordinatesOperators[i]) { - operator = coordinatesOperators[i]; - break; - } - } - } - - //calculate units and shortcuts - rawScroll = operator !== undefined ? rawScroll.substr(2) : rawScroll; - rawScroll = rawScroll.replace(/min/g, 0); //'min' = 0% - rawScroll = rawScroll.replace(//g, (normalizeShortcuts ? '-' : _strEmpty) + _strHundredPercent); //'>' = 100% - rawScroll = rawScroll.replace(/px/g, _strEmpty); - rawScroll = rawScroll.replace(/%/g, mult + (maxScroll * (isRTLisX && _rtlScrollBehavior.n ? -1 : 1) / 100.0)); - rawScroll = rawScroll.replace(/vw/g, mult + _viewportSize.w); - rawScroll = rawScroll.replace(/vh/g, mult + _viewportSize.h); - amount = parseIntToZeroOrNumber(window.parseFloat(window.eval(rawScroll)).toFixed()); - } - else if (helper.type(rawScroll) === TYPES.n) { - amount = rawScroll; - } - - if (!isNaN(amount) && amount !== undefined && helper.type(amount) === TYPES.n) { - var normalizeIsRTLisX = _normalizeRTLCache && 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; - } - if (invert) - finalValue = maxScroll - finalValue; - if (negate) - finalValue *= -1; - - if (isRTLisX && _rtlScrollBehavior.n) { - finalValue = Math.max(maxScroll, finalValue); - finalValue = Math.min(0, finalValue); - } - else { - finalValue = Math.min(maxScroll, finalValue); - finalValue = Math.max(0, finalValue); - } - if (finalValue === currScroll) - finalValue = undefined; - } - return finalValue; - }; - - if (possibleElementIsJQuery || possibleElementIsHTMLElement) { - var finalElement = possibleElementIsJQuery ? possibleElement : helper(possibleElement); - if (finalElement.length === 0) - return; - - //get settings - if (coordinatesIsElementObj) { - var valid; - var axis = coordinates.axis; - var block = coordinates.block; - var blockType = helper.type(block); - var blockLength; - var margin = coordinates.margin; - var marginType = helper.type(margin); - var marginLength; - - //block can be [ string, or array of two strings ] - if (blockType === TYPES.s) - block = [block, block]; - else if (blockType === TYPES.a) { - blockLength = block.length; - if (blockLength > 2 || blockLength < 1) - block = undefined; - else { - valid = true; - if (blockLength === 1) - block[1] = strBegin; - for (i = 0; i < blockLength; i++) { - var item = block[i]; - if (helper.type(item) !== TYPES.s || !checkSettingsStringValue(item, elementObjSettingsBlockValues)) { - valid = false; - break; - } - } - if (!valid) - block = undefined; - } - } - else - block = undefined; - - //margin can be [ true, false, number, array of 2 numbers, array of 4 numbers ] - if (marginType === TYPES.n) - margin = [margin, margin, margin, margin]; - else if (marginType === 'boolean') { - if (margin) { - margin = [ - parseIntToZeroOrNumber(finalElement.css(_strMarginMinus + _strTop)), - parseIntToZeroOrNumber(finalElement.css(_strMarginMinus + _strRight)), - parseIntToZeroOrNumber(finalElement.css(_strMarginMinus + _strBottom)), - parseIntToZeroOrNumber(finalElement.css(_strMarginMinus + _strLeft)) - ]; - } - else - margin = [0, 0, 0, 0]; - } - else if (marginType === TYPES.a) { - marginLength = margin.length; - if (marginLength !== 2 && marginLength !== 4) - margin = undefined; - else { - valid = true; - for (i = 0; i < marginLength; i++) { - if (helper.type(margin[i]) !== TYPES.n) { - valid = false; - break; - } - } - if (valid) { - if (marginLength === 2) - margin = [margin[0], margin[1], margin[0], margin[1]]; - } - else - margin = undefined; - } - } - else - margin = undefined; - - elementObjSettings.axis = checkSettingsStringValue(axis, elementObjSettingsAxisValues) ? axis : elementObjSettings.axis; - elementObjSettings.block = block || elementObjSettings.block; - elementObjSettings.margin = margin || elementObjSettings.margin; - } - - //get coordinates - var elementOffset = finalElement.offset(); - var viewportOffset = _paddingElement.offset(); // use padding element instead of viewport element because padding element has never padding, margin or position applied. - var viewportScroll = { - l: _scrollHorizontalInfo.cs, - t: _scrollVerticalInfo.cs - }; - var settingsAxis = elementObjSettings.axis; - var settingsBlock = elementObjSettings.block; - var settingsMargin = elementObjSettings.margin; - var blockIsEnd = { - x : settingsBlock[0] === (_isRTL ? strBegin : strEnd), - y : settingsBlock[1] === strEnd - }; - var blockIsCenter = { - x : settingsBlock[0] === strCenter, - y : settingsBlock[1] === strCenter - }; - var blockIsNearest = { - x : settingsBlock[0] === strNearest, - y : settingsBlock[1] === strNearest - }; - var doNothing = { }; - var measuringForBlockIsRequired = blockIsEnd.x || blockIsEnd.y || blockIsCenter.x || blockIsCenter.y || blockIsNearest.x || blockIsNearest.y; - elementOffset.top -= settingsMargin[0]; - elementOffset.left -= settingsMargin[3]; - var elementScrollCoordinates = { - x: Math.round(elementOffset.left - viewportOffset.left + viewportScroll.l), - y: Math.round(elementOffset.top - viewportOffset.top + viewportScroll.t) - }; - if (_isRTL) { - if (!_rtlScrollBehavior.n && !_rtlScrollBehavior.i) - elementScrollCoordinates.x = Math.round(viewportOffset.left - elementOffset.left + viewportScroll.l); - if (_rtlScrollBehavior.n && _normalizeRTLCache) - elementScrollCoordinates.x *= -1; - if (_rtlScrollBehavior.i && _normalizeRTLCache) - elementScrollCoordinates.x = Math.round(viewportOffset.left - elementOffset.left + (_scrollHorizontalInfo.ms - viewportScroll.l)); - } - - if (measuringForBlockIsRequired) { - var rawElementSize = {}; - var rect; - if (_supportTransform) { - rect = finalElement[0].getBoundingClientRect(); - rawElementSize = { - w: rect[_strWidth], - h: rect[_strHeight] - }; - } - else { - rawElementSize = { - w: finalElement[0][WORDING.oW], - h: finalElement[0][WORDING.oH] - }; - } - var elementSize = { - w: rawElementSize.w + settingsMargin[3] + settingsMargin[1], - h: rawElementSize.h + settingsMargin[0] + settingsMargin[2] - }; - var finalizeBlock = function(isX) { - var scrollbarVars = getScrollbarVars(isX); - var divide = blockIsCenter[scrollbarVars.xy] ? 2 : 1; - var elementCenterOffset = elementOffset[scrollbarVars.lt] + (elementSize[scrollbarVars._wh] / 2); - var viewportCenterOffset = viewportOffset[scrollbarVars.lt] + (_viewportSize[scrollbarVars._wh] / 2); - - if(blockIsNearest[scrollbarVars.xy]) { - //if element is completely in view don't scroll on this axis - doNothing[scrollbarVars.xy] = elementSize[scrollbarVars._wh] <= _viewportSize[scrollbarVars._wh] && elementOffset[scrollbarVars.lt] >= viewportOffset[scrollbarVars.lt] && elementOffset[scrollbarVars.lt] + elementSize[scrollbarVars._wh] <= viewportOffset[scrollbarVars.lt] + _viewportSize[scrollbarVars._wh]; - blockIsEnd[scrollbarVars.xy] = elementSize[scrollbarVars._wh] < _viewportSize[scrollbarVars._wh] ? elementCenterOffset > viewportCenterOffset : elementCenterOffset < viewportCenterOffset; - } - - if (blockIsEnd[scrollbarVars.xy] || blockIsCenter[scrollbarVars.xy]) - elementScrollCoordinates[scrollbarVars.xy] -= ((_viewportSize[scrollbarVars._wh] / divide) - (elementSize[scrollbarVars._wh] / divide)) * (isX && _isRTL && _normalizeRTLCache ? -1 : 1); - }; - finalizeBlock(true); - finalizeBlock(false); - } - - if (settingsAxis === _strX || doNothing.y) - delete elementScrollCoordinates.y; - if (settingsAxis === _strY || doNothing.x) - delete elementScrollCoordinates.x; - - coordinates = elementScrollCoordinates; } - finalScroll.x = getFinalScroll(true, getRawScroll(coordinates).x); - finalScroll.y = getFinalScroll(false, getRawScroll(coordinates).y); - var scrollLeft = finalScroll.x !== undefined; - var scrollTop = finalScroll.y !== undefined; - - if (duration > 0 || durationIsObject) { - var animateObj = { }; - if (scrollLeft) - animateObj[_strScrollLeft] = finalScroll.x; - if (scrollTop) - animateObj[_strScrollTop] = finalScroll.y; - - if (durationIsObject) { - _viewportElement.animate(animateObj, duration); - } - else { - var animateOpt = { - duration : duration, - complete : complete - }; - if(helper.type(easing) === TYPES.a) { - var specialEasing = { }; - specialEasing[_strScrollLeft] = easing[0]; - specialEasing[_strScrollTop] = easing[1]; - animateOpt.specialEasing = specialEasing; - } - else { - animateOpt.easing = easing; - } - _viewportElement.animate(animateObj, animateOpt); - } + /** + * 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)); } - else { - if (scrollLeft) - _viewportElement[_strScrollLeft](finalScroll.x); - if (scrollTop) - _viewportElement[_strScrollTop](finalScroll.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]; } - }; - /** - * Stops all scroll animations. - */ - _base.scrollStop = function (param1, param2, param3) { - _viewportElement.stop(param1, param2, param3); - }; + /** + * 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 helper.prototype.find.call(el, selector).first(); + } - /** - * Returns all relevant elements. - * @returns {{target: *, host: *, padding: *, viewport: *, content: *, scrollbarHorizontal: {scrollbar: *, track: *, handle: *}, scrollbarVertical: {scrollbar: *, track: *, handle: *}, scrollbarCorner: *}} - */ - _base.getElements = function () { - return { - 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 - }; - }; + /** + * 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) + + '
'; + } - /** - * 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 (!helper.isPlainObject(obj)) - return obj; - var extended = helper.extend(true, {}, obj); - byPropertyPath.del(extended, 'c'); - var changePropertyName = function (from, to) { - if (extended.hasOwnProperty(from)) { - extended[to] = extended[from]; - delete extended[from]; - } - }; - changePropertyName('w', _strWidth); - changePropertyName('h', _strHeight); - 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) - }; - if (helper.type(stateProperty) === TYPES.s) - return byPropertyPath.get(obj, stateProperty); - return obj; - }; + /** + * 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; + } - /** - * Constructs the plugin. - * @param targetElement The element to which the plugin shall be applied. - * @param options The initial options of the plugin. - * @returns {boolean} True if the plugin was successfully initialized, false otherwise. - */ - function construct(targetElement, options) { - _defaultOptions = globals.defaultOptions; - _nativeScrollbarStyling = globals.nativeScrollbarStyling; - _nativeScrollbarSize = helper.extend(true, {}, globals.nativeScrollbarSize); - _nativeScrollbarIsOverlaid = helper.extend(true, {}, globals.nativeScrollbarIsOverlaid); - _overlayScrollbarDummySize = helper.extend(true, {}, globals.overlayScrollbarDummySize); - _rtlScrollBehavior = helper.extend(true, {}, globals.rtlScrollBehavior); + /** + * 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; + helper.extend(obj, extendObjRoot, true); + } - //parse & set options but don't update - setOptions(helper.extend(true, {}, _defaultOptions, options)); - var optionsCallbacks = _currentPreparedOptions.callbacks; + //==== Utils Cache ====// - //check if the plugin hasn't to be initialized - if (_nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.x && !_currentPreparedOptions.nativeScrollbarsOverlaid.initialize) { - var onInitializationWithdrawn = optionsCallbacks.onInitializationWithdrawn; - if (helper.isFunction(onInitializationWithdrawn)) - callCallback(onInitializationWithdrawn); + /** + * 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; } - _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 = helper(targetElement.ownerDocument); - _windowElement = helper(_documentElement[0].defaultView || _documentElement[0].parentWindow); - _htmlElement = _documentElement.find('html').first(); - _bodyElement = _htmlElement.find('body').first(); - _targetElement = helper(targetElement); - _isTextarea = _targetElement.is('textarea'); - _isBody = _targetElement.is('body'); - - 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]()); + /** + * 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; } - //build Hide-scrollbars DOM - if (_isTextarea) { - _targetElement.wrap(_strDivBegin + _classNameHostTextareaElement + _strDivEnd); - _targetElement.addClass(_classNameTextareaElement) - .addClass(_classNameTextInherit); - _hostElement = _targetElement.parent(); + /** + * 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; + } - var hostElementCSS = {}; - if (!_currentPreparedOptions.sizeAutoCapable) { - hostElementCSS[_strWidth] = _targetElement.css(_strWidth); - hostElementCSS[_strHeight] = _targetElement.css(_strHeight); + + //==== Shortcuts ====// + + /** + * jQuery type method shortcut. + */ + function type(obj) { + return helper.type(obj); + } + + /** + * jQuery extend method shortcut. + */ + function extend() { + return helper.extend.apply(this, arguments); + } + + /** + * jQuery addClass method shortcut. + */ + function addClass(el, classes) { + return helper.prototype.addClass.call(el, classes); + } + + /** + * jQuery removeClass method shortcut. + */ + function removeClass(el, classes) { + return helper.prototype.removeClass.call(el, classes); + } + + /** + * jQuery remove method shortcut. + */ + function remove(el) { + return helper.prototype.remove.call(el); + } + + + //==== 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" 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 isZoom = force === 'zoom'; + var imgElementSelector = 'img'; + var imgElementLoadEvent = 'load'; + if (force === _strAuto) { + attrsChanged = meaningfulAttrsChanged(); + contentSizeC = updateAutoContentSizeChanged(); + if (attrsChanged || contentSizeC) + update(false, contentSizeC); } - _hostElement.css(hostElementCSS) - .wrapInner(_strDivBegin + _classNameContentElement + _strSpace + _classNameTextInherit + _strDivEnd) - .wrapInner(_strDivBegin + _classNameViewportElement + _strSpace + _classNameTextInherit + _strDivEnd) - .wrapInner(_strDivBegin + _classNamePaddingElement + _strSpace + _classNameTextInherit + _strDivEnd); - _contentElement = _hostElement.find(_strDot + _classNameContentElement).first(); - _viewportElement = _hostElement.find(_strDot + _classNameViewportElement).first(); - _paddingElement = _hostElement.find(_strDot + _classNamePaddingElement).first(); - _textareaCoverElement = helper(_strDivBegin + _classNameTextareaCoverElement + _strDivEnd); - _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 if (isZoom) { + update(true, true); } else { - _targetElement.on(_strKeyDownEvent, textareaOnKeyDown) - .on(_strKeyUpEvent, textareaOnKeyUp); + force = _isSleeping || force; + _isSleeping = false; + update(false, false, force); } - } else { - _targetElement.addClass(_classNameHostElement); - _hostElement = _targetElement; - _hostElement.wrapInner(_strDivBegin + _classNameContentElement + _strDivEnd) - .wrapInner(_strDivBegin + _classNameViewportElement + _strDivEnd) - .wrapInner(_strDivBegin + _classNamePaddingElement + _strDivEnd); - _contentElement = _hostElement.find(_strDot + _classNameContentElement).first(); - _viewportElement = _hostElement.find(_strDot + _classNameViewportElement).first(); - _paddingElement = _hostElement.find(_strDot + _classNamePaddingElement).first(); - - //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) { - if (_nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.y) - _viewportElement.addClass(_classNameViewportNativeScrollbarsOverlaid); - else - _viewportElement.addClass(_classNameViewportNativeScrollbarsInvisible); - } - - //build mutation observers - if (_supportMutationObserver) { - var mutationObserver = compatibility.mO(); - var contentLastUpdate = compatibility.now(); - var contentTimeout; - - _mutationObserverHost = new mutationObserver(function (mutations) { - if (!_initialized || _isSleeping) - return; - var doUpdate = false; - helper.each(mutations, function () { - var t = this; - var target = this.target; - var attrName = t.attributeName; - - if (attrName === WORDING.c) - doUpdate = hostClassNamesChanged(t.oldValue, target.className); - else if (attrName === WORDING.s) - doUpdate = t.oldValue !== target.style.cssText; - else - doUpdate = true; - - if (doUpdate) - return false; - }); - if (doUpdate) - _base.update(_strAuto); - }); - _mutationObserverContent = new mutationObserver(function (mutations) { - if (!_initialized || _isSleeping) - return; - - var doUpdate = false; - for (var i = 0; i < mutations.length; i++) { - var mutation = mutations[i]; - if (isUnknownMutation(mutation)) { - doUpdate = true; - break; + if(!_isTextarea && !isZoom) { + _contentElement.find(imgElementSelector).each(function(i, el) { + var index = helper.inArray(el, _imgs); + if (index === -1) { + el = helper(el); + el.off(imgElementLoadEvent, imgOnLoad).on(imgElementLoadEvent, imgOnLoad); } - } - - if (doUpdate) { - var now = compatibility.now(); - var sizeAuto = (_heightAutoCache || _widthAutoCache); - var action = function () { - contentLastUpdate = now; - //if cols, rows or wrap attr was changed - if (_isTextarea) - textareaUpdate(); - - if (sizeAuto) - _base.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) { - _htmlElement.addClass(_classNameHTMLElement); - - //apply the body scroll to handle it right in the update method - _viewportElement[_strScrollLeft](initBodyScroll.l); - _viewportElement[_strScrollTop](initBodyScroll.t); - } - _sizeObserverElement = helper(_strDivBegin + 'os-resize-observer-host' + _strDivEnd); - _hostElement.prepend(_sizeObserverElement); - addResizeObserver(_sizeObserverElement, onHostResized); - - //update for the first time - onHostResized(); //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) - _hostElement.addClass(_classNameHostTransition); - }, 333); - - //the plugin is initialized now! - _initialized = true; - var onInitialized = optionsCallbacks.onInitialized; - if (helper.isFunction(onInitialized)) { - callCallback(onInitialized); - } - return _initialized; - }; - - if (construct(pluginTargetElement, options)) { - instances.add(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. - * @returns {*} - */ - window[PLUGINNAME] = function(pluginTargetElements, options) { - if(arguments.length === 0) - return this; - - initOverlayScrollbarsStatics(); - - var arr = [ ]; - var inst; - if(helper.isPlainObject(options)) { - if (pluginTargetElements && pluginTargetElements.length) { - if(pluginTargetElements.length > 1) { - helper.each(pluginTargetElements, function () { - inst = this; - if(inst !== undefined) - arr.push(OverlayScrollbarsInstance(inst, options, _pluginGlobals, _pluginAutoUpdateLoop)); }); - return arr; } - else - return OverlayScrollbarsInstance(pluginTargetElements[0], options, _pluginGlobals, _pluginAutoUpdateLoop) - } - else - return OverlayScrollbarsInstance(pluginTargetElements, options, _pluginGlobals, _pluginAutoUpdateLoop); - } - else { - if(pluginTargetElements) { - if(pluginTargetElements.length && pluginTargetElements.length > 0) { - if(pluginTargetElements.length > 1) { - helper.each(pluginTargetElements, function() { - inst = instances.get(this); - if(options === '!') { - if(inst !== undefined) - arr.push(inst); - } - else - arr.push(inst); - }); - return arr; + }; + + /** + 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 (helper.isEmptyObject(newOptions) || !helper.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 instances.get(pluginTargetElements[0]); + 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); + + 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++) + helper(_imgs[i]).off('load', imgOnLoad); + _imgs = undefined; + + instances.rem(pluginTargetElement); + callCallback(_currentPreparedOptions.callbacks.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 defined, else this object isn't valid. + * axis : [string], Default value is 'xy'. + * block : [string], Default value is 'begin'. + * margin : [number, array, boolean] Default value is false. + * } + * + * Possible axis settings are: + * 'x' Scrolls only the x axis. + * 'y' Scrolls only the y axis. + * 'xy' Scrolls both axis. + * 'yx' Same as 'xy' + * + * 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 edges. + * [ string, string ] Specify Begin or End for each axis individually. + * + * Possible margin settings are: -- The actual margin of the element wont be affect, this option affects only the final scroll offset. + * true The true margin of the element will be used. + * false No margin will be used. + * [NUMBER] The margin will be used for all edges. + * [ [NUMBER], [NUMBER] ] The first margin number will be used for the margin of the X axis egdes (left and right) and the second number will be used for the Y axis edges (top and bottom). + * [ [NUMBER], [NUMBER],[NUMBER], [NUMBER] ] Each edge gets its own margin value, the first value stays for the top margin, the second for the right margin, the third for the bottom margin and the forth for the left margin. + * + * @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 coordinatesXAxisProps = [_strX, _strLeft, 'l']; + var coordinatesYAxisProps = [_strY, _strTop, 't']; + var coordinatesOperators = ['+=', '-=', '*=', '/=']; + var i; + var finalScroll = { }; + var durationIsObject = type(duration) === TYPES.o; + var strEnd = 'end'; + var strBegin = 'begin'; + var strCenter = 'center'; + var strNearest = 'nearest'; + var elementObjSettings = { + axis: 'xy', + block: [strBegin, strBegin], + margin: [0, 0, 0, 0] + }; + var elementObjSettingsAxisValues = [_strX, _strY, 'xy', 'yx']; + var elementObjSettingsBlockValues = [strBegin, strEnd, strCenter, strNearest]; + var coordinatesIsElementObj = coordinates.hasOwnProperty('el'); + var possibleElement = coordinatesIsElementObj ? coordinates.el : coordinates; + var possibleElementIsJQuery = possibleElement instanceof helper || possibleElement instanceof window.jQuery; + var possibleElementIsHTMLElement = possibleElementIsJQuery ? false : isHTMLElement(possibleElement); + var checkSettingsStringValue = function (currValue, allowedValues) { + for (i = 0; i < allowedValues.length; i++) { + if (currValue === allowedValues[i]) + return true; + } + return false; + }; + var getRawScroll = function (coordinates) { + var rawScroll = {}; + if (type(coordinates) === TYPES.a && coordinates.length > 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) { + 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.length; 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 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 && !_normalizeRTLCache; + var strReplace = 'replace'; + if (type(rawScroll) === TYPES.s) { + //check operator + if (rawScroll.length > 2) { + var possibleOperator = rawScroll.substr(0, 2); + for (i = 0; i < coordinatesOperators.length; 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 = parseIntToZeroOrNumber(window.parseFloat(window.eval(rawScroll)).toFixed()); + } + else if (type(rawScroll) === TYPES.n) { + amount = rawScroll; + } + + if (!isNaN(amount) && amount !== undefined && type(amount) === TYPES.n) { + var normalizeIsRTLisX = _normalizeRTLCache && 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; + } + if (invert) + finalValue = maxScroll - finalValue; + if (negate) + finalValue *= -1; + + if (isRTLisX && _rtlScrollBehavior.n) { + finalValue = Math.max(maxScroll, finalValue); + finalValue = Math.min(0, finalValue); + } + else { + finalValue = Math.min(maxScroll, finalValue); + finalValue = Math.max(0, finalValue); + } + if (finalValue === currScroll) + finalValue = undefined; + } + return finalValue; + }; + + if (possibleElementIsJQuery || possibleElementIsHTMLElement) { + var finalElement = possibleElementIsJQuery ? possibleElement : helper(possibleElement); + if (finalElement.length === 0) + return; + + //get settings + if (coordinatesIsElementObj) { + var valid; + var axis = coordinates.axis; + var block = coordinates.block; + var blockType = type(block); + var blockLength; + var margin = coordinates.margin; + var marginType = type(margin); + var marginLength; + + //block can be [ string, or array of two strings ] + if (blockType === TYPES.s) + block = [block, block]; + else if (blockType === TYPES.a) { + blockLength = block.length; + if (blockLength > 2 || blockLength < 1) + block = undefined; + else { + valid = true; + if (blockLength === 1) + block[1] = strBegin; + for (i = 0; i < blockLength; i++) { + var item = block[i]; + if (type(item) !== TYPES.s || !checkSettingsStringValue(item, elementObjSettingsBlockValues)) { + valid = false; + break; + } + } + if (!valid) + block = undefined; + } + } + else + block = undefined; + + //margin can be [ true, false, number, array of 2 numbers, array of 4 numbers ] + if (marginType === TYPES.n) + margin = [margin, margin, margin, margin]; + else if (marginType === TYPES.b) { + if (margin) { + margin = [ + parseIntToZeroOrNumber(finalElement.css(_strMarginMinus + _strTop)), + parseIntToZeroOrNumber(finalElement.css(_strMarginMinus + _strRight)), + parseIntToZeroOrNumber(finalElement.css(_strMarginMinus + _strBottom)), + parseIntToZeroOrNumber(finalElement.css(_strMarginMinus + _strLeft)) + ]; + } + else + margin = [0, 0, 0, 0]; + } + else if (marginType === TYPES.a) { + marginLength = margin.length; + if (marginLength !== 2 && marginLength !== 4) + margin = undefined; + else { + valid = true; + for (i = 0; i < marginLength; i++) { + if (type(margin[i]) !== TYPES.n) { + valid = false; + break; + } + } + if (valid) { + if (marginLength === 2) + margin = [margin[0], margin[1], margin[0], margin[1]]; + } + else + margin = undefined; + } + } + else + margin = undefined; + + elementObjSettings.axis = checkSettingsStringValue(axis, elementObjSettingsAxisValues) ? axis : elementObjSettings.axis; + elementObjSettings.block = block || elementObjSettings.block; + elementObjSettings.margin = margin || elementObjSettings.margin; + } + + //get coordinates + var elementOffset = finalElement.offset(); + var viewportOffset = _paddingElement.offset(); // use padding element instead of viewport element because padding element has never padding, margin or position applied. + var viewportScroll = { + l: _scrollHorizontalInfo.cs, + t: _scrollVerticalInfo.cs + }; + var settingsAxis = elementObjSettings.axis; + var settingsBlock = elementObjSettings.block; + var settingsMargin = elementObjSettings.margin; + var blockIsEnd = { + x : settingsBlock[0] === (_isRTL ? strBegin : strEnd), + y : settingsBlock[1] === strEnd + }; + var blockIsCenter = { + x : settingsBlock[0] === strCenter, + y : settingsBlock[1] === strCenter + }; + var blockIsNearest = { + x : settingsBlock[0] === strNearest, + y : settingsBlock[1] === strNearest + }; + var doNothing = { }; + var measuringForBlockIsRequired = blockIsEnd.x || blockIsEnd.y || blockIsCenter.x || blockIsCenter.y || blockIsNearest.x || blockIsNearest.y; + elementOffset.top -= settingsMargin[0]; + elementOffset.left -= settingsMargin[3]; + var elementScrollCoordinates = { + x: Math.round(elementOffset.left - viewportOffset.left + viewportScroll.l), + y: Math.round(elementOffset.top - viewportOffset.top + viewportScroll.t) + }; + if (_isRTL) { + if (!_rtlScrollBehavior.n && !_rtlScrollBehavior.i) + elementScrollCoordinates.x = Math.round(viewportOffset.left - elementOffset.left + viewportScroll.l); + if (_rtlScrollBehavior.n && _normalizeRTLCache) + elementScrollCoordinates.x *= -1; + if (_rtlScrollBehavior.i && _normalizeRTLCache) + elementScrollCoordinates.x = Math.round(viewportOffset.left - elementOffset.left + (_scrollHorizontalInfo.ms - viewportScroll.l)); + } + + if (measuringForBlockIsRequired) { + var rawElementSize = {}; + var rect; + if (_supportTransform) { + rect = finalElement[0].getBoundingClientRect(); + rawElementSize = { + w: rect[_strWidth], + h: rect[_strHeight] + }; + } + else { + rawElementSize = { + w: finalElement[0][LEXICON.oW], + h: finalElement[0][LEXICON.oH] + }; + } + var elementSize = { + w: rawElementSize.w + settingsMargin[3] + settingsMargin[1], + h: rawElementSize.h + settingsMargin[0] + settingsMargin[2] + }; + var finalizeBlock = function(isX) { + var scrollbarVars = getScrollbarVars(isX); + var divide = blockIsCenter[scrollbarVars.xy] ? 2 : 1; + var elementCenterOffset = elementOffset[scrollbarVars.lt] + (elementSize[scrollbarVars._wh] / 2); + var viewportCenterOffset = viewportOffset[scrollbarVars.lt] + (_viewportSize[scrollbarVars._wh] / 2); + + if(blockIsNearest[scrollbarVars.xy]) { + //if element is completely in view don't scroll on this axis + doNothing[scrollbarVars.xy] = elementSize[scrollbarVars._wh] <= _viewportSize[scrollbarVars._wh] && elementOffset[scrollbarVars.lt] >= viewportOffset[scrollbarVars.lt] && elementOffset[scrollbarVars.lt] + elementSize[scrollbarVars._wh] <= viewportOffset[scrollbarVars.lt] + _viewportSize[scrollbarVars._wh]; + blockIsEnd[scrollbarVars.xy] = elementSize[scrollbarVars._wh] < _viewportSize[scrollbarVars._wh] ? elementCenterOffset > viewportCenterOffset : elementCenterOffset < viewportCenterOffset; + } + + if (blockIsEnd[scrollbarVars.xy] || blockIsCenter[scrollbarVars.xy]) + elementScrollCoordinates[scrollbarVars.xy] -= ((_viewportSize[scrollbarVars._wh] / divide) - (elementSize[scrollbarVars._wh] / divide)) * (isX && _isRTL && _normalizeRTLCache ? -1 : 1); + }; + finalizeBlock(true); + finalizeBlock(false); + } + + if (settingsAxis === _strX || doNothing.y) + delete elementScrollCoordinates.y; + if (settingsAxis === _strY || doNothing.x) + delete elementScrollCoordinates.x; + + coordinates = elementScrollCoordinates; + } + + finalScroll.x = getFinalScroll(true, getRawScroll(coordinates).x); + finalScroll.y = getFinalScroll(false, getRawScroll(coordinates).y); + var scrollLeft = finalScroll.x !== undefined; + var scrollTop = finalScroll.y !== undefined; + + if (duration > 0 || durationIsObject) { + var animateObj = { }; + if (scrollLeft) + animateObj[_strScrollLeft] = finalScroll.x; + if (scrollTop) + animateObj[_strScrollTop] = finalScroll.y; + + if (durationIsObject) { + _viewportElement.animate(animateObj, duration); + } + else { + var animateOpt = { + duration : duration, + complete : complete + }; + if(type(easing) === TYPES.a) { + var specialEasing = { }; + specialEasing[_strScrollLeft] = easing[0]; + specialEasing[_strScrollTop] = easing[1]; + animateOpt.specialEasing = specialEasing; + } + else { + animateOpt.easing = easing; + } + _viewportElement.animate(animateObj, animateOpt); + } + } + else { + if (scrollLeft) + _viewportElement[_strScrollLeft](finalScroll.x); + if (scrollTop) + _viewportElement[_strScrollTop](finalScroll.y); + } + }; + + /** + * Stops all scroll animations. + */ + _base.scrollStop = function (param1, param2, param3) { + _viewportElement.stop(param1, param2, param3); + }; + + /** + * Returns all relevant elements. + * @returns {{target: *, host: *, padding: *, viewport: *, content: *, scrollbarHorizontal: {scrollbar: *, track: *, handle: *}, scrollbarVertical: {scrollbar: *, track: *, handle: *}, scrollbarCorner: *}} + */ + _base.getElements = function () { + return { + 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 + }; + }; + + /** + * 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 (!helper.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) + }; + if (type(stateProperty) === TYPES.s) + return getObjectPropVal(obj, stateProperty); + return obj; + }; + + /** + * Constructs the plugin. + * @param targetElement The element to which the plugin shall be applied. + * @param options The initial options of the plugin. + * @returns {boolean} True if the plugin was successfully initialized, false otherwise. + */ + function construct(targetElement, options) { + _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)); + + var optionsCallbacks = _currentPreparedOptions.callbacks; + + //check if the plugin hasn't to be initialized + if (_nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.x && !_currentPreparedOptions.nativeScrollbarsOverlaid.initialize) { + callCallback(optionsCallbacks.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 = helper(targetElement.ownerDocument); + _windowElement = helper(_documentElement[0].defaultView || _documentElement[0].parentWindow); + _htmlElement = findFirst(_documentElement, 'html'); + _bodyElement = findFirst(_htmlElement, 'body'); + _targetElement = helper(targetElement); + _isTextarea = _targetElement.is('textarea'); + _isBody = _targetElement.is('body'); + + 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 = helper(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 mutation; + helper.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.style.cssText; + else + doUpdate = true; + + if (doUpdate) + return false; + }); + + if (doUpdate) + _base.update(_strAuto); + }); + _mutationObserverContent = new mutationObserver(function (mutations) { + if (!_initialized || _isSleeping) + return; + + var doUpdate = false; + var mutation; + helper.each(mutations, function () { + mutation = this; + doUpdate = isUnknownMutation(mutation); + return !doUpdate; + }); + + if (doUpdate) { + now = compatibility.now(); + sizeAuto = (_heightAutoCache || _widthAutoCache); + action = function () { + contentLastUpdate = now; + + //if cols, rows or wrap attr was changed + if (_isTextarea) + textareaUpdate(); + + if (sizeAuto) + _base.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 = helper(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(optionsCallbacks.onInitialized); + return _initialized; + } + + if (construct(pluginTargetElement, options)) { + instances.add(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. + * @returns {*} + */ + window[PLUGINNAME] = function(pluginTargetElements, options) { + if(arguments.length === 0) + return this; + + initOverlayScrollbarsStatics(); + + var arr = [ ]; + var inst; + var result; + if(helper.isPlainObject(options)) { + if (pluginTargetElements && pluginTargetElements.length) { + helper.each(pluginTargetElements, function () { + inst = this; + console.log(inst); + if(inst !== undefined) + arr.push(OverlayScrollbarsInstance(inst, options, _pluginsGlobals, _pluginsAutoUpdateLoop)); + }); + result = arr.length > 1 ? arr : arr[0]; } else - return instances.get(pluginTargetElements); + result = OverlayScrollbarsInstance(pluginTargetElements, options, _pluginsGlobals, _pluginsAutoUpdateLoop); } - } - }; + else if(pluginTargetElements) { + if(pluginTargetElements.length && pluginTargetElements.length > 0) { + helper.each(pluginTargetElements, function() { + inst = instances.get(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.get(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 = helper.extend(true, { }, _pluginGlobals); - delete globals['msie']; - return globals; - }; + /** + * 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 = helper.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 = _pluginGlobals.defaultOptions; - if(newDefaultOptions === undefined) - return helper.extend(true, { }, currDefaultOptions); + /** + * 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 helper.extend(true, { }, currDefaultOptions); - //set the new default options - _pluginGlobals.defaultOptions = helper.extend(true, { }, currDefaultOptions , newDefaultOptions); - }; - })(COMPATIBILITY, INSTANCES, HELPER, BYPROPERTYPATH); + //set the new default options + _pluginsGlobals.defaultOptions = helper.extend(true, { }, currDefaultOptions , _pluginsOptions.v(newDefaultOptions, _pluginsOptions.t, true)); + }; - var jQuery = window.jQuery; - 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. - * @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) { - var _elements = this; - if(jQuery.isPlainObject(options)) { - jQuery.each(_elements, function() { window[PLUGINNAME](this, options); }); - return _elements; - } - else - return window[PLUGINNAME](_elements, options); - }; + return window[PLUGINNAME]; + })(COMPATIBILITY, INSTANCES, FRAMEWORK); + + var jQuery = window.jQuery; + 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. + * @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) { + var _elements = this; + if(jQuery.isPlainObject(options)) { + jQuery.each(_elements, function() { PLUGIN(this, options); }); + return _elements; + } + else + return PLUGIN(_elements, options); + }; + } + + return PLUGIN; } - - return window[PLUGINNAME]; -}))); +)); diff --git a/js/OverlayScrollbars.min.js b/js/OverlayScrollbars.min.js index 1f7a658..e58d9d0 100644 --- a/js/OverlayScrollbars.min.js +++ b/js/OverlayScrollbars.min.js @@ -2,12 +2,12 @@ * OverlayScrollbars * https://github.com/KingSora/OverlayScrollbars * - * Version: 1.4.1 - * + * Version: 1.4.2 + * * Copyright KingSora. * https://github.com/KingSora * * Released under the MIT license. - * Date: 22.03.2018 + * Date: 14.04.2018 */ -!function(e,t){"function"==typeof define&&define.amd?define(function(){return t(e,e.document,undefined)}):"object"==typeof exports?module.exports=t(e,e.document,undefined):t(e,e.document,undefined)}("undefined"!=typeof window?window:this,function(e,t,n){"use-strict";var r="OverlayScrollbars",i={o:"object",f:"function",a:"array",s:"string",n:"number",u:"undefined"},o={c:"class",s:"style",i:"id",oH:"offsetHeight",cH:"clientHeight",sH:"scrollHeight",oW:"offsetWidth",cW:"clientWidth",sW:"scrollWidth"},a={wW:function(){return e.innerWidth||t.documentElement[o.cW]||t.body[o.cW]},wH:function(){return e.innerHeight||t.documentElement[o.cH]||t.body[o.cH]},mO:function(){return e.MutationObserver||e.WebKitMutationObserver||e.WebkitMutationObserver||e.MozMutationObserver||n},rO:function(){return e.ResizeObserver||e.WebKitResizeObserver||e.WebkitResizeObserver||e.MozResizeObserver||n},rAF:function(){return e.requestAnimationFrame||e.webkitRequestAnimationFrame||e.mozRequestAnimationFrame||e.oRequestAnimationFrame||e.msRequestAnimationFrame||function(t){return e.setTimeout(t,1e3/60)}},cAF:function(){return e.cancelAnimationFrame||e.webkitCancelAnimationFrame||e.mozCancelAnimationFrame||e.oCancelAnimationFrame||e.msCancelAnimationFrame||function(t){return e.clearTimeout(t)}},now:function(){return Date.now()||(new Date).getTime()},stpP:function(e){e.stopPropagation?e.stopPropagation():e.cancelBubble=!0},prvD:function(e){e.preventDefault?e.preventDefault():e.returnValue=!1},page:function(e){var r="page",i="client",o="X",a="Y",s=((e=e.originalEvent||e).target||e.srcElement||t).ownerDocument||t,l=s.documentElement,c=s.body;if(e.touches!==n){var u=e.touches[0];return{x:u[r+o],y:u[r+a]}}return!e[r+o]&&e[i+o]&&null!=e[i+o]?{x:e[i+o]+(l&&l.scrollLeft||c&&c.scrollLeft||0)-(l&&l.clientLeft||c&&c.clientLeft||0),y:e[i+a]+(l&&l.scrollTop||c&&c.scrollTop||0)-(l&&l.clientTop||c&&c.clientTop||0)}:{x:e[r+o],y:e[r+a]}},mBtn:function(e){return e.which||e.button===n?e.which:1&e.button?1:2&e.button?3:4&e.button?2:0},bind:function(e,t){if(typeof e!==i.f)throw"Can't bind function!";var n=Array.prototype.slice.call(arguments,2),r=function(){},o=function(){return e.apply(this instanceof r?this:t,n.concat(Array.prototype.slice.call(arguments)))};return e.prototype&&(r.prototype=e.prototype),o.prototype=new r,o}},s=function(r){var o=/[^\x20\t\r\n\f]+/g,a=Object.prototype.toString,s=" ",l="",c=[],u={animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},f={swing:function(e,t,n,r,i){return.5-Math.cos(e*Math.PI)/2},linear:function(e,t,n,r,i){return e},easeInQuad:function(e,t,n,r,i){return r*(t/=i)*t+n},easeOutQuad:function(e,t,n,r,i){return-r*(t/=i)*(t-2)+n},easeInOutQuad:function(e,t,n,r,i){return(t/=i/2)<1?r/2*t*t+n:-r/2*(--t*(t-2)-1)+n},easeInCubic:function(e,t,n,r,i){return r*(t/=i)*t*t+n},easeOutCubic:function(e,t,n,r,i){return r*((t=t/i-1)*t*t+1)+n},easeInOutCubic:function(e,t,n,r,i){return(t/=i/2)<1?r/2*t*t*t+n:r/2*((t-=2)*t*t+2)+n},easeInQuart:function(e,t,n,r,i){return r*(t/=i)*t*t*t+n},easeOutQuart:function(e,t,n,r,i){return-r*((t=t/i-1)*t*t*t-1)+n},easeInOutQuart:function(e,t,n,r,i){return(t/=i/2)<1?r/2*t*t*t*t+n:-r/2*((t-=2)*t*t*t-2)+n},easeInQuint:function(e,t,n,r,i){return r*(t/=i)*t*t*t*t+n},easeOutQuint:function(e,t,n,r,i){return r*((t=t/i-1)*t*t*t*t+1)+n},easeInOutQuint:function(e,t,n,r,i){return(t/=i/2)<1?r/2*t*t*t*t*t+n:r/2*((t-=2)*t*t*t*t+2)+n},easeInSine:function(e,t,n,r,i){return-r*Math.cos(t/i*(Math.PI/2))+r+n},easeOutSine:function(e,t,n,r,i){return r*Math.sin(t/i*(Math.PI/2))+n},easeInOutSine:function(e,t,n,r,i){return-r/2*(Math.cos(Math.PI*t/i)-1)+n},easeInExpo:function(e,t,n,r,i){return 0==t?n:r*Math.pow(2,10*(t/i-1))+n},easeOutExpo:function(e,t,n,r,i){return t==i?n+r:r*(1-Math.pow(2,-10*t/i))+n},easeInOutExpo:function(e,t,n,r,i){return 0==t?n:t==i?n+r:(t/=i/2)<1?r/2*Math.pow(2,10*(t-1))+n:r/2*(2-Math.pow(2,-10*--t))+n},easeInCirc:function(e,t,n,r,i){return-r*(Math.sqrt(1-(t/=i)*t)-1)+n},easeOutCirc:function(e,t,n,r,i){return r*Math.sqrt(1-(t=t/i-1)*t)+n},easeInOutCirc:function(e,t,n,r,i){return(t/=i/2)<1?-r/2*(Math.sqrt(1-t*t)-1)+n:r/2*(Math.sqrt(1-(t-=2)*t)+1)+n},easeInElastic:function(e,t,n,r,i){var o=1.70158,a=0,s=r;if(0==t)return n;if(1==(t/=i))return n+r;if(a||(a=.3*i),s0&&t-1 in e)}function m(e){return(e.match(o)||[]).join(s)}function g(e,n){for(var r=(e.parentNode||t).querySelectorAll(n)||[],i=r.length;i--;)if(r[i]==e)return!0;return!1}function w(e,t,n){h.type(n)===i.s?e.insertAdjacentHTML(t,n):n.nodeType?e.insertAdjacentElement(t,n):e.insertAdjacentElement(t,n[0])}function x(e,t,r){try{e.style[t]!==n&&(e.style[t]=b(t,r))}catch(i){}}function b(e,t){return u[e.toLowerCase()]||h.type(t)!==i.n||(t=t+="px"),t}function C(e,t){var n,r;!1!==t&&e.q.splice(0,1),e.q.length>0?(r=e.q[0],M(e.el,r.props,r.duration,r.easing,r.complete,!0)):(n=h.inArray(e,c))>-1&&c.splice(n,1)}function O(e,t,n){"scrollLeft"===t?e[t]=n:"scrollTop"===t?e[t]=n:x(e,t,n)}function M(e,t,n,i,o,a){var s,l,u,v,p,y,m={},g={},w=0,x=h.isPlainObject(n);for(x?(i=n.easing,n.start,u=n.progress,v=n.step,p=n.specialEasing,o=n.complete,y=n.duration):y=n,p=p||{},y=y||400,i=i||"swing",a=a||!1;w0)H=r.now(),k=function(){for(s in b=r.now(),I=b-H,M=L.stop||I>=y,S=1-(Math.max(0,H+y-b)/y||0),g)T=m[s],z=g[s],E=(z-T)*f[p[s]||i](S,S*y,0,1,y)+T,O(e,s,E),d(v)&&v(E,{elem:e,prop:s,start:T,now:E,end:z,pos:S,options:{easing:i,speacialEasing:p,duration:y,complete:o,step:v},startTime:H});d(u)&&u({},S,Math.max(0,y-I)),M?(C(l),d(o)&&o()):L.frame=r.rAF()(k)},L.frame=r.rAF()(k);else{for(s in g)O(e,s,g[s]);C(l)}}}function S(e,t,n){for(var i,o,a,s=0;s0){if((o=i.q[0]).stop=!0,r.cAF()(o.frame),i.q.splice(0,1),n)for(a in o.props)O(e,a,o.props[a]);t?i.q=[]:C(i,!1)}break}}function A(e){var t=this;h.type(e)===i.s||e.length||(e=[e]);for(var n=0;n-1)return!0;return!1},addClass:function(e){var t,r,i,a,l,c,u=null,f=0,h=0;if(e)for(t=e.match(o)||[];r=this[f++];)if(u===n&&(u=r.classList!==n),u)for(;l=t[h++];)r.classList.add(l);else if(a=r.className,i=1===r.nodeType&&s+m(a)+s){for(;l=t[h++];)i.indexOf(s+l+s)<0&&(i+=l+s);a!==(c=m(i))&&(r.className=c)}return this},removeClass:function(e){var t,r,i,a,l,c,u=null,f=0,h=0;if(e)for(t=e.match(o)||[];r=this[f++];)if(u===n&&(u=r.classList!==n),u)for(;l=t[h++];)r.classList.remove(l);else if(a=r.className,i=1===r.nodeType&&s+m(a)+s){for(;l=t[h++];)for(;i.indexOf(s+l+s)>-1;)i=i.replace(s+l+s,s);a!==(c=m(i))&&(r.className=c)}return this},remove:function(){return this.each(function(){var e=this;null!=e.parentNode&&e.parentNode.removeChild(e)})},offset:function(){var n=this[0].getBoundingClientRect(),r=e.pageXOffset||t.documentElement.scrollLeft,i=e.pageYOffset||t.documentElement.scrollTop;return{top:n.top+i,left:n.left+r}},css:function(t,r){var o,a;return h.type(t)===i.s?r===n?(o=this[0],e.getComputedStyle?e.getComputedStyle(o,null).getPropertyValue(t):o.currentStyle[t]):this.each(function(){x(this,t,r)}):this.each(function(){for(a in t)x(this,a,t[a])})},unwrap:function(){var e,t,n,r=[];for(this.each(function(){n=this.parentNode,-1===h.inArray(n,r)&&r.push(n)}),e=0;e0;)i=i.childNodes[0];for(t=0;n.length-t;i.firstChild===n[0]&&t++)i.appendChild(n[t]);var s=a?a.nextSibling:o.firstChild;return o.insertBefore(r,s),this},wrapInner:function(e){return this.each(function(){var t=new A(this),n=t.contents();n.length?n.wrapAll(e):t.append(e)})},wrap:function(e){return this.each(function(){new h(this).wrapAll(e)})},contents:function(){var e,t,n=[];return this.each(function(){for(e=this.childNodes,t=0;t-1&&(delete n[r],t.splice(i,1))}function a(e){return s(e)!==n}function s(e){for(var n=0;n
'),f=function(){a.append(u);var e,t="overflow",n="hidden",r=u[0],s=c(u.children("div").first());return 0===r[o.oH]&&u.hide().show(),e={x:r[o.oH]-r[o.cH],y:r[o.oW]-r[o.cW]},i.restrictedMeasuring=function(){u.css(t,n);var e={w:r[o.sW],h:r[o.sH]};u.css(t,"visible");var i={w:r[o.sW],h:r[o.sH]};return e.w-i.w!=0||e.h-i.h!=0}(),i.nativeScrollbarStyling=(u.addClass("os-viewport-native-scrollbars-invisible"),u.css(t,n).hide().css(t,"scroll").show(),r[o.oH]-r[o.cH]==0&&r[o.oW]-r[o.cW]==0),i.rtlScrollBehavior=function(){u.css({"overflow-y":n,direction:"rtl"}).scrollLeft(0);var e=u.offset(),t=s.offset();u.scrollLeft(999);var r=s.offset();return{i:e.left===t.left,n:t.left-r.left==0}}(),u.removeAttr(o.s).remove(),e}(),h={x:0===f.x,y:0===f.y};function v(e){var r=!1,i="Webkit Moz ms O".split(" "),o=t.createElement("div"),a=null;if(e=e.toLowerCase(),o.style[e]!==n&&(r=!0),!1===r){a=e.charAt(0).toUpperCase()+e.substr(1);for(var s=0;s0)return parseInt(t.substring(n+5,t.indexOf(".",n)),10);if(t.indexOf("Trident/")>0){var r=t.indexOf("rv:");return parseInt(t.substring(r+3,t.indexOf(".",r)),10)}var i=t.indexOf("Edge/");return i>0&&parseInt(t.substring(i+5,t.indexOf(".",i)),10)}(),i.cssCalc=function(){for(var e=t.createElement("div"),n=["calc","-webkit-calc","-moz-calc","-o-calc"],r=0;r0){var e=s.wW(),h=s.wH(),d=e-t,p=h-n;if(0===d&&0===p)return;var y=Math.round(e/(t/100)),m=Math.round(h/(n/100)),g=Math.abs(d),w=Math.abs(p),x=Math.abs(y),b=Math.abs(m),C=v(),O=g>2&&w>2,M=!f(x,b);if(!!(O&&M&&(C!==r&&r>0))){a.append(u);var S=u[0];i.nativeScrollbarSize={x:S[o.oH]-S[o.cH],y:S[o.oW]-S[o.cW]},u.remove(),c.each(l.all(),function(){l.has(this)&&l.get(this).update("zoom")})}t=e,n=h,r=C}})}function f(e,t){var n=Math.abs(e),r=Math.abs(t);return!(n===r||n+1===r||n-1===r)}function v(){var t=e.screen.deviceXDPI||0,n=e.screen.logicalXDPI||1;return e.devicePixelRatio||t/n}}()}function y(e){var t,r=this,i="autoUpdate",o=i+"Interval",a=[],l=[],u=!1,f=33,h=f,v=s.now(),d=function(){if(a.length>0&&u){t=s.rAF()(function(){d()});var e=s.now(),r=e-v;if(r>h){v=e-r%h;for(var c=f,p=0;pw&&(y.update("auto"),l[p]=new Date(x+=w)),c=Math.max(1,Math.min(c,w))}}h=c}}else h=f};r.add=function(t){-1===c.inArray(t,a)&&(a.push(t),l.push(s.now()),a.length>0&&!u&&(u=!0,e.autoUpdateLoop=u,d()))},r.remove=function(r){var i=c.inArray(r,a);i>-1&&(l.splice(i,1),a.splice(i,1),0===a.length&&u&&(u=!1,e.autoUpdateLoop=u,t!==n&&(s.cAF()(t),t=-1)))}}function m(t,f,h,v){if(ri(t)){if(l.has(t)){var d=l.get(t);return d.options(f),d}var p,y,m,g,w,x,b,C,O,M,S,A,T,z,E,H,k,I,W,L,P,F,N,D,R,B,j,q,_,U,Q,V,X,Y,J,K,$,G,Z,ee,te,ne,re,ie,oe,ae,se,le,ce,ue,fe,he,ve,de,pe,ye,me,ge,we,xe,be,Ce,Oe,Me,Se,Ae,Te,ze,Ee,He,ke,Ie,We,Le,Pe,Fe,Ne,De,Re,Be,je,qe,_e,Ue,Qe,Ve,Xe,Ye,Je,Ke,$e,Ge,Ze,et,tt,nt,rt,it,ot,at,st,lt,ct,ut,ft,ht,vt,dt,pt,yt,mt,gt,wt,xt,bt=new e[r],Ct=!1,Ot=!1,Mt=!1,St=!1,At=!1,Tt={w:0,h:0},zt={},Et={},Ht={},kt=175,It="-hidden",Wt="margin-",Lt="padding-",Pt="border-",Ft="top",Nt="right",Dt="bottom",Rt="left",Bt="min-",jt="max-",qt="width",_t="height",Ut="float",Qt="",Vt="auto",Xt="scroll",Yt="100%",Jt="x",Kt="y",$t='
',Zt=".",en=" ",tn="scrollbar",nn="-horizontal",rn="-vertical",on=Xt+"Left",an=Xt+"Top",sn="mousedown touchstart",ln="mouseup touchend",cn="mousemove touchmove",un="mouseenter",fn="mouseleave",hn="keydown",vn="keyup",dn="selectstart",pn="transitionend webkitTransitionEnd oTransitionEnd",yn="__overlayScrollbarsRO__",mn="os-",gn=mn+"html",wn=mn+"host",xn=wn+"-textarea",bn=wn+"-"+tn+nn+It,Cn=wn+"-"+tn+rn+It,On=wn+"-transition",Mn=wn+"-rtl",Sn=wn+"-resize-disabled",An=wn+"-scrolling",Tn=wn+"-overflow",zn=Tn+"-x",En=Tn+"-y",Hn=mn+"textarea",kn=Hn+"-cover",In=mn+"padding",Wn=mn+"viewport",Ln=Wn+"-native-scrollbars-invisible",Pn=Wn+"-native-scrollbars-overlaid",Fn=mn+"content",Nn=mn+"content-arrange",Dn=mn+"content-glue",Rn=mn+"size-auto-observer",Bn=mn+"resize-observer",jn=mn+"resize-observer-item",qn=jn+"-final",_n=mn+"text-inherit",Un=mn+tn,Qn=Un+"-track",Vn=Qn+"-off",Xn=Un+"-handle",Yn=Xn+"-off",Jn=Un+"-unusable",Kn=Un+"-"+Vt+It,$n=Un+"-corner",Gn=$n+"-resize",Zn=Gn+"-both",er=Gn+nn,tr=Gn+rn,nr=Un+nn,rr=Un+rn,ir=mn+"dragging",or=mn+"theme-none",ar={},sr=33,lr=[],cr=11,ur=[112,113,114,115,116,117,118,119,120,121,123,33,34,37,38,39,40,16,17,18,19,20,144],fr=[],hr={x:0,y:0},vr={w:0,h:0};if(bt.sleep=function(){N=!0},bt.update=function(e){var t,n,r="zoom"===e,i="img",o="load";e===Vt?(t=hi(),n=fi(),(t||n)&&yi(!1,n)):r?yi(!0,!0):(e=N||e,N=!1,yi(!1,!1,e)),Mt||r||ne.find(i).each(function(e,t){-1===c.inArray(t,lr)&&(t=c(t)).off(o,qr).on(o,qr)})},bt.options=function(e,t){if(c.isEmptyObject(e)||!c.isPlainObject(e)){if(c.type(e)===i.s){if(arguments.length>=2){var n={};return u.set(n,e,t,!0),ui(n),void yi()}return u.get(B,e)}return B}ui(e);var r=N||!1;N=!1,yi(),N=r},bt.destroy=function(){Ot=!0,v.remove(bt),Tr(),xr($),At&&xr(K),$.remove(),G!==n&&G.remove(),te!==n&&te.remove(),At&&K.remove(),A?(yr(J,cn,ei),yr(J,un,Gr),yr(J,fn,Zr)):J.off(cn,ei).off(un,Gr).off(fn,Zr),oe.remove(),le.remove(),ie&&ie.remove(),mt||Hr(),ne.contents().unwrap().unwrap().unwrap(),St&&V.removeClass(gn),Mt?(Y.off(Xt,Br).off("drop",Nr).off("focus",Dr).off("focusout",Rr),m>9||!y?Y.off("input",Lr):Y.off(hn,Pr).off(vn,Fr),re.remove(),Y.removeClass(Hn).removeClass(_n).unwrap().removeAttr(o.s),J.remove()):(Y.removeClass(wn),J.removeClass(wn).removeClass(Sn).removeClass(Mn).removeClass(bn).removeClass(Cn).removeClass(On).removeClass(An).removeClass(Tn).removeClass(zn).removeClass(En).removeClass(or).removeClass(Ke));for(var e=0;e0)t.x=e[0],t.y=e[1];else if(c.type(e)===i.s||c.type(e)===i.n)t.x=e,t.y=e;else if(c.type(e)===i.o){for(var n in e=c.extend({},e),m=0,e)e.hasOwnProperty(n)&&(m>2&&delete e[n],m++);var r=function(t){var n=t?g:w;for(m=0;m2){var y=r.substr(0,2);for(m=0;m/g,(d?"-":Qt)+Yt)).replace(/px/g,Qt)).replace(/%/g,h+f*(v&&p.n?-1:1)/100)).replace(/vw/g,h+Ht.w)).replace(/vh/g,h+Ht.h),a=vi(e.parseFloat(e.eval(r)).toFixed())}else c.type(r)===i.n&&(a=r);if(!isNaN(a)&&a!==n&&c.type(a)===i.n){var g=Je&&v,w=u*(g&&p.n?-1:1),b=g&&p.i,C=g&&p.n;switch(w=b?f-w:w,o){case"+=":s=w+a;break;case"-=":s=w-a;break;case"*=":s=w*a;break;case"/=":s=w/a;break;default:s=a}b&&(s=f-s),C&&(s*=-1),v&&p.n?(s=Math.max(f,s),s=Math.min(0,s)):(s=Math.min(f,s),s=Math.max(0,s)),s===u&&(s=n)}return s};if(W||L){var R=W?I:c(I);if(0===R.length)return;if(k){var B,j,q,_=t.axis,U=t.block,Q=c.type(U),V=t.margin,X=c.type(V);if(Q===i.s)U=[U,U];else if(Q===i.a)if((j=U.length)>2||j<1)U=n;else{for(B=!0,1===j&&(U[1]=M),m=0;m=K[t.lt]&&J[t.lt]+fe[t._wh]<=K[t.lt]+Ht[t._wh],re[t.xy]=fe[t._wh]i:r0||C){var pe={};if(ve&&(pe[on]=b.x),de&&(pe[an]=b.y),C)ee.animate(pe,r);else{var ye={duration:r,complete:s};if(c.type(a)===i.a){var me={};me[on]=a[0],me[an]=a[1],ye.specialEasing=me}else ye.easing=a;ee.animate(pe,ye)}}else ve&&ee[on](b.x),de&&ee[an](b.y)},bt.scrollStop=function(e,t,n){ee.stop(e,t,n)},bt.getElements=function(){return{target:Y[0],host:J[0],padding:Z[0],viewport:ee[0],content:ne[0],scrollbarHorizontal:{scrollbar:oe[0],track:ae[0],handle:se[0]},scrollbarVertical:{scrollbar:le[0],track:ce[0],handle:ue[0]},scrollbarCorner:ie}},bt.getState=function(e){var t=function(e){if(!c.isPlainObject(e))return e;var t=c.extend(!0,{},e);u.del(t,"c");var n=function(e,n){t.hasOwnProperty(e)&&(t[n]=t[e],delete t[e])};return n("w",qt),n("h",_t),t},n={sleeping:t(N)||!1,autoUpdate:t(!rt),widthAuto:t(ye),heightAuto:t(me),padding:t(xe),overflowAmount:t(Ee),hideOverflow:t(pe),hasOverflow:t(de),contentScrollSize:t(he),viewportSize:t(Ht),hostSize:t(fe)};return c.type(e)===i.s?u.get(n,e):n},mi(t,f))return l.add(t,bt),bt;bt=n}function dr(){if(!N){var e=$[0],t={w:e[o.sW],h:e[o.sH]};if(Ct){var n=Cr(t,_e);_e=t,n&&yi(!0,!1)}else _e=t}}function pr(e,t,n){for(var r=t.split(en),i=0;i9||!y){var f='">',v="",d="childNodes",g=$t+Bn+f;g+=$t+jn+'" dir="ltr'+f,g+=$t+jn+f,g+=$t+qn+Gt,g+=v,g+=$t+jn+f,g+=$t+qn+'" style="width: 200%; height: 200%'+Gt,g+=v,g+=v,g+=v,e.prepend(g);var w,x,b,C,O=(e=e[0])[d][0][d][0],M=c(O[d][1]),S=c(O[d][0]),A=c(S[0][d][0]),z=O[o.oW],E=O[o.oH],H=2,k=h.nativeScrollbarSize,I=function(){S[on](n)[an](n),M[on](n)[an](n)},W=function(){x=0,w&&(z=b,E=C,r())},L=function(e){return b=O[o.oW],C=O[o.oH],w=b!=z||C!=E,e&&w&&!x?(s.cAF()(x),x=s.rAF()(W)):e||W(),I(),e&&(s.prvD(e),s.stpP(e)),!1},P={};P[Ft]=-(k.y+1)*H,P[Nt]=k.x*-H,P[Dt]=k.y*-H,P[Rt]=-(k.x+1)*H,c(O).css(P),S.on(Xt,L),M.on(Xt,L),c(e).on(u,function(){L(!1)});var N={};N[qt]=n,N[_t]=n,A.css(N),I()}else{var D=Q[0],R=e;e=e[0];var B=D.attachEvent,j=typeof navigator===i.u||(navigator.userAgent.match(/Trident/)||navigator.userAgent.match(/Edge/));if(B)R.prepend($t+Bn+Gt),R.find(Zt+Bn).first()[0].attachEvent("onresize",r);else{var q=D.createElement(i.o);q.setAttribute("tabindex","-1"),q.setAttribute(o.c,Bn),q.onload=function(){var e=this.contentDocument.defaultView;e.addEventListener("resize",r),e.document.documentElement.style.display="none"},q.type="text/html",j&&R.prepend(q),q.data="about:blank",j||R.prepend(q),R.on(u,r)}}}if((e=c(e))[0]===$[0]){var _=function(){var t=J.css("direction");if(t!==Me){var r={},i=0;return"ltr"===t?(r[Rt]=0,r[Nt]=Vt,i=n):(r[Rt]=Vt,r[Nt]=0,i=p.n?-n:p.i?0:n),$.children().first().css(r),e.scrollLeft(i),e.scrollTop(n),Me=t,!0}return!1};_(),e.on(Xt,function(e){return _()&&yi(),s.prvD(e),s.stpP(e),!1})}}function xr(e){if(T){var t=e.contents()[0];t[yn].disconnect(),delete t[yn]}else e.children(Zt+Bn).first().remove()}function br(e,t,r){return!0===r?r:t===n||e!==t}function Cr(e,t,r,i,o){if(!0===o)return o;if(i===n&&o===n){if(!0===r)return r;r=n}return r=r===n?"w":r,i=i===n?"h":i,t===n||(e[r]!==t[r]||e[i]!==t[i])}function Or(e,t){return t===n||(e.t!==t.t||e.r!==t.r||e.b!==t.b||e.l!==t.l)}function Mr(e,t){Ct&&e.call(bt,t)}function Sr(e,t,r){r===n&&(r=[Qt,Qt,Qt,Qt]),e[t+Ft]=r[0],e[t+Nt]=r[1],e[t+Dt]=r[2],e[t+Rt]=r[3]}function Ar(){it&&!rt&&(tt.observe(J[0],{attributes:!0,attributeOldValue:!0,attributeFilter:[o.i,o.c,o.s]}),nt.observe(Mt?Y[0]:ne[0],{attributes:!0,attributeOldValue:!0,subtree:!Mt,childList:!Mt,characterData:!Mt,attributeFilter:Mt?["wrap","cols","rows"]:[o.i,o.c,o.s]}),rt=!0)}function Tr(){it&&rt&&(tt.disconnect(),nt.disconnect(),rt=!1)}function zr(e){if(!N){var t=(e.originalEvent||e).touches!==n;(1===s.mBtn(e)||t)&&(rt&&(yt=!0,Tr()),hr=s.page(e),vr.w=J[0][o.oW]-(E?0:H),vr.h=J[0][o.oH]-(E?0:k),Q.on(dn,jr).on(cn,Er).on(ln,Hr),X.addClass(ir),ie.setCapture&&ie.setCapture(),s.prvD(e),s.stpP(e))}}function Er(e){e.originalEvent;var t=s.page(e),n={};(wt||gt)&&(n[qt]=vr.w+t.x-hr.x),(xt||gt)&&(n[_t]=vr.h+t.y-hr.y),J.css(n),s.stpP(e)}function Hr(e){var t=e!==n;Q.off(dn,jr).off(cn,Er).off(ln,Hr),X.removeClass(ir),ie.releaseCapture&&ie.releaseCapture(),t&&(yt&&Ar(),bt.update(Vt)),yt=!1}function kr(){if(!N){var e=!We,t=Ht.w-(E||Se||!ye?0:k+W),n=Ht.h-(E||Se||!me?0:k+W),r={},i=ye||e,a=Y[0];r[Bt+qt]=Qt,r[Bt+_t]=Qt,r[qt]=Vt,Y.css(r);var s=a[o.oW],l=i?Math.max(s,a[o.sW]-1):1;l+=ye?L+(E?0:e?0:H+I):0,r[qt]=ye?l:Yt,r[_t]=Vt,Y.css(r);var c=a[o.oH],u=Math.max(c,a[o.sH]-1);return r[qt]=l,r[_t]=u,re.css(r),r[Bt+qt]=t+(!E&&ye?H+I:0),r[Bt+_t]=n+(!E&&me?k+W:0),Y.css(r),{ow:s,oh:c,dw:l,dh:u}}}function Ir(){var e=Y.prop("selectionStart");if(e!==n){for(var t=Y.val(),r=t.length,i=t.split("\n"),o=i.length,a=t.substr(0,e).split("\n"),s=0,l=0,c=a.length,u=a[a.length-1].length,f=0;fl&&(s=f+1,l=h)}return{cursorRow:c,cursorCol:u,rows:o,cols:l,wRow:s,pos:e,max:r}}}function Wr(e){for(var t=0;t-1&&fr.splice(n,1),0===fr.length&&(kr(),bt.update(Vt),clearInterval(ot))}}function Nr(){setTimeout(function(){kr(),bt.update(Vt)},50)}function Dr(){at=!0}function Rr(){at=!1,clearInterval(ot),fr=[],kr(),bt.update(Vt)}function Br(e){return Y[on](p.i&&Je?9999999:0),Y[an](0),s.prvD(e),s.stpP(e),!1}function jr(e){return s.prvD(e),!1}function qr(){yi()}function _r(){return He&&C.x&&C.y}function Ur(e,t,n){var r=e?bn:Cn,i=e?oe:le;t?J.removeClass(r):J.addClass(r),n?i.removeClass(Jn):i.addClass(Jn)}function Qr(e,t){if(clearTimeout(st),e)oe.removeClass(Kn),le.removeClass(Kn);else{var n="active",r=function(){if(!pt){var e=se.hasClass(n)||ue.hasClass(n);!e&&(ft||ht||vt)&&oe.addClass(Kn),!e&&(ft||ht||vt)&&le.addClass(Kn)}};ct>0&&!0!==t?st=setTimeout(r,ct):r()}}function Vr(e){var t={},n=$r(e),r=Math.min(1,(fe[n._wh]-(Se?e?H:k:0))/he[n._wh]);t[n.wh]=Math.floor(100*r*1e5)/1e5+"%",_r()||n.h.css(t),n.i.hl=n.h[0]["offset"+n.WH],n.i.hlr=r}function Xr(e,t){var n=F&&e,r={},i=$r(e),o=ee[0][Xt+i.WH]-ee[0]["client"+i.WH];p.n&&n&&(o*=-1);var a=t/o;a=isNaN(a)?0:Math.min(1,a),i.i.ms=o,i.i.cs=t,i.i.csr=a;var s=i.i.hl,l=i.t[0]["offset"+i.WH],c=(l-s)*a;if(c=isNaN(c)?0:c,n&&(p.n||!p.n&&!p.i)&&(c=l-s-c),c=Math.max(0,c),S){var u;n&&(c=-(l-s-c));var f="translate(",h="transform";u=e?f+c+"px, 0px)":f+"0px, "+c+"px)",r["-webkit-"+h]=u,r["-moz-"+h]=u,r["-ms-"+h]=u,r["-o-"+h]=u,r[h]=u}else r[i.lt]=c;_r()||i.h.css(r),i.i.ho=c,i.i.tl=l}function Yr(e,t){var n=t?"removeClass":"addClass",r=e?ce:ue,i=e?Vn:Yn;(e?ae:se)[n](i),r[n](i)}function Jr(){oe=c($t+Un+en+nr+Gt),ae=c($t+Qn+Gt),se=c($t+Xn+Gt),le=c($t+Un+en+rr+Gt),ce=c($t+Qn+Gt),ue=c($t+Xn+Gt),oe.append(ae),ae.append(se),le.append(ce),ce.append(ue),Z.after(le),Z.after(oe),M&&(oe.on(pn,function(e){e.target===oe[0]&&(Vr(!0),Xr(!0,ee[on]()))}),le.on(pn,function(e){e.target===le[0]&&(Vr(!1),Xr(!1,ee[an]()))})),Kr(!0),Kr(!1),ie=c($t+en+$n+Gt),J.append(ie)}function Kr(e){var t,r,i,o=$r(e),a=o.xy,l=Xt+o.LT,c="active",u=1,f=function(){u=.5},h=function(){u=1},v=function(n){n.originalEvent;var i=o.i.tl,c=o.i.hl,u=o.i.ms*((c/2+s.page(n)[a]-r-c/2)/(i-c));u=isFinite(u)?u:0,F&&e&&(p.n||!p.n&&!p.i)&&(u*=-1),ee[l](t+u),A||s.prvD(n)},d=function(e){e=e||e.originalEvent,X.removeClass(ir),o.h.removeClass(c),o.t.removeClass(c),o.s.removeClass(c),A?(yr(Q,cn,v),yr(Q,ln,d),yr(Q,hn,y),yr(Q,vn,m)):Q.off(cn,v).off(ln,d).off(hn,y).off(vn,m),Q.off(dn,jr),h(),t=n,r=n,i!==n&&(bt.scrollStop(),clearTimeout(i),i=n);var a=J[0].getBoundingClientRect();e.clientX>=a.left&&e.clientX<=a.right&&e.clientY>=a.top&&e.clientY<=a.bottom||Zr(),(ft||ht)&&Qr(!1)},y=function(e){16==e.keyCode&&f()},m=function(e){16==e.keyCode&&h()};o.h.on(sn,function(i){if(!N){var u=(i.originalEvent||i).touches!==n;_r()||!Xe||u&&!dt||(1===s.mBtn(i)||u)&&(t=(t=ee[l]())===n?0:t,(F&&e&&!p.n||!F)&&(t=t<0?0:t),r=s.page(i)[a],X.addClass(ir),o.h.addClass(c),o.s.addClass(c),A?(pr(Q,cn,v),pr(Q,ln,d)):Q.on(cn,v).on(ln,d),Q.on(dn,jr),s.prvD(i))}}),o.t.on(sn,function(t){if(!N){var l=(t.originalEvent||t).touches!==n;if(!_r()&&Ve&&(!l||dt)&&(1===s.mBtn(t)||l)){var h,v=Ht[o._wh],g=o.t.offset()[o.lt],w=!0;t.shiftKey&&f();var x=function(){var t=o.i.ho,a=o.i.hl,s=r-g,l=200*u,c=w?Math.max(333,l):l,f={},d=F&&e&&(!p.i&&!p.n||Je),y=t>s;d&&(y=t=s;d&&(m=h?t+a>=s:t<=s),m?(clearTimeout(i),bt.scrollStop(),i=n):i=setTimeout(x,c),w=!1};r=s.page(t)[a],X.addClass(ir),o.t.addClass(c),o.s.addClass(c),A?(pr(Q,ln,d),pr(Q,hn,y),pr(Q,vn,m)):Q.on(ln,d).on(hn,y).on(vn,m),Q.on(dn,jr),x(),s.prvD(t)}}}).hover(function(){(ft||ht)&&(pt=!0,Qr(!0))},function(){(ft||ht)&&(pt=!1,Qr(!1))}),o.s.on(sn,function(e){s.stpP(e)})}function $r(e){return{wh:e?qt:_t,WH:e?"Width":"Height",lt:e?Rt:Ft,LT:e?"Left":"Top",xy:e?Jt:Kt,XY:e?"X":"Y",_wh:e?"w":"h",_lt:e?"l":"t",t:e?ae:ce,h:e?se:ue,s:e?oe:le,i:e?zt:Et}}function Gr(){vt&&Qr(!0)}function Zr(){vt&&!X.hasClass(ir)&&Qr(!1)}function ei(){ht&&(Qr(!0),clearTimeout(lt),lt=setTimeout(function(){ht&&Qr(!1)},100))}function ti(e){if(!N){var t=j.callbacks,r=t.onScrollStart,i=t.onScroll,o=t.onScrollStop;D!==n?clearTimeout(D):((ft||ht)&&Qr(!0),_r()||J.addClass(An),c.isFunction(r)&&Mr(r,e)),Xr(!0,ee[on]()),Xr(!1,ee[an]()),c.isFunction(i)&&Mr(i,e),D=setTimeout(function(){ni(e),c.isFunction(o)&&Mr(o,e)},kt)}}function ni(){clearTimeout(D),D=n,(ft||ht)&&Qr(!1),_r()||J.removeClass(An)}function ri(e){return typeof HTMLElement===i.o?e instanceof HTMLElement:e&&typeof e===i.o&&null!==e&&1===e.nodeType&&typeof e.nodeName===i.s}function ii(e,t,r,o){var a,s,l,f,h,v={n:t,s:!1,v:n,p:n},d=i.u,p=u.has(e,t),y=u.get(e,t),m=!1,g=!0!==p,w="*",x=!1;for(c.type(r)!==i.a&&(r=[r]),h=r.length,s=0;s1){var C=0;for(f=0;f1)break}1===C&&(x=!0)}else x=!0;b===n&&(m=!0)}if(g&&!1===p&&m&&(g=!1),!g){a=y,d=c.type(a);var M=function(e){var t=c.type(e);return t===d&&(t!==i.s||(!!x||a===e))&&(v.s=!0,v.v=a,v.p=a,!0)};for(s=0;s-1&&o.splice(u,1);for(var f=0;f0&&Ct&&i-q0?J.addClass(ce):J.addClass(or)),ot&&(!0===it?(Tr(),v.add(bt)):null===it&&y?(Tr(),v.add(bt)):(v.remove(bt),Ar())),_e)if(qe)if(G===n&&(G=c($t+Dn+Gt),Z.before(G)),At)K.show();else{K=c($t+Rn+Gt),G.before(K);var Et={w:-1,h:-1};wr(K,function(){var e={w:K[0][o.oW],h:K[0][o.oH]};Cr(e,Et)&&(Ct&&me&&e.h>0||ye&&e.w>0?yi():(Ct&&!me&&0===e.h||!ye&&0===e.w)&&yi()),Et=e}),At=!0,null!==w&&K.css(_t,w+"(100% + 1px)")}else At&&K.hide();r&&($.find("*").trigger(Xt),At&&K.find("*").trigger(Xt));var kt,It=J.css("direction"),Zt=br(It,Oe,r),en=J.css("box-sizing"),tn=br(en,we,r),nn={c:r,t:vi(J.css(Lt+Ft)),r:vi(J.css(Lt+Nt)),b:vi(J.css(Lt+Dt)),l:vi(J.css(Lt+Rt))};try{kt=At?K[0].getBoundingClientRect():null}catch(Di){return}E="border-box"===en;var rn=(F="rtl"===It)?Rt:Nt,ln=F?Nt:Rt,hn=J[0],vn=Z[0],dn=!1,pn=!(!At||"none"===J.css(Ut))&&(0===Math.round(kt.right-kt.left)&&(!!De||hn[o.cW]-H>0));if(qe&&!pn){var yn=hn[o.oW],mn=G.css(qt);G.css(qt,Vt);var gn=hn[o.oW];G.css(qt,mn),(dn=yn!==gn)||(G.css(qt,yn+1),gn=hn[o.oW],G.css(qt,mn),dn=yn!==gn)}var wn=(pn||dn)&&qe,xn=br(wn,ye,r),bn=!wn&&ye,Cn=!!At&&0===Math.round(kt.bottom-kt.top),On=br(Cn,me,r),Hn=!Cn&&me,kn="-"+qt,In=wn&&E||!E,Wn=Cn&&E||!E,Ln={c:r,t:Wn?vi(J.css(Pt+Ft+kn)):0,r:In?vi(J.css(Pt+Nt+kn)):0,b:Wn?vi(J.css(Pt+Dt+kn)):0,l:In?vi(J.css(Pt+Rt+kn)):0},Pn={c:r,t:vi(J.css(Wt+Ft)),r:vi(J.css(Wt+Nt)),b:vi(J.css(Wt+Dt)),l:vi(J.css(Wt+Rt))},Fn={h:String(J.css(jt+_t)),w:String(J.css(jt+qt))},Bn={},jn={};if(H=nn.l+nn.r,k=nn.t+nn.b,nn.c=Or(nn,xe),I=Ln.l+Ln.r,W=Ln.t+Ln.b,Ln.c=Or(Ln,be),L=Pn.l+Pn.r,P=Pn.t+Pn.b,Pn.c=Or(Pn,Ce),Fn.ih=vi(Fn.h),Fn.iw=vi(Fn.w),Fn.ch=Fn.h.indexOf("px")>-1,Fn.cw=Fn.w.indexOf("px")>-1,Fn.c=Cr(Fn,ge,r),Oe=It,we=en,ye=wn,me=Cn,xe=nn,be=Ln,Ce=Pn,ge=Fn,Zt&&At&&K.css(Ut,ln),nn.c||Zt||Re||xn||On||tn||_e){var qn={},_n={};Sr(jn,Wt,[-nn.t,-nn.r,-nn.b,-nn.l]),De?(Sr(qn,Qt,[nn.t,nn.r,nn.b,nn.l]),Sr(Mt?_n:Bn,Lt)):(Sr(qn,Qt),Sr(Mt?_n:Bn,Lt,[nn.t,nn.r,nn.b,nn.l])),Z.css(qn),Y.css(_n)}Ht={w:vn[o.oW],h:vn[o.oH]};var Un=!!Mt&&kr();if(Cn&&(On||Re||tn||Fn.c||nn.c||Ln.c)?(Fn.cw&&(Bn[jt+_t]=Fn.ch?Fn.ih-(De?k:0)+(E?-W:k):Qt),Bn[_t]=Vt):(On||Re)&&(Bn[jt+_t]=Qt,Bn[_t]=Yt),wn&&(xn||Re||tn||Fn.c||nn.c||Ln.c||Zt)?(Fn.cw&&(Bn[jt+qt]=Fn.cw?Fn.iw-(De?H:0)+(E?-I:H)+(C.y?O.y:0):Qt),Bn[qt]=Vt,jn[jt+qt]=Yt):(xn||Re)&&(Bn[jt+qt]=Qt,Bn[qt]=Yt,Bn[Ut]=Qt,jn[jt+qt]=Qt),wn&&(Fn.cw||(Bn[jt+qt]=Qt),jn[qt]=Mt&&pt?Un.dw:Vt,Bn[qt]=Vt,Bn[Ut]=ln),Cn&&(Fn.ch||(Bn[jt+_t]=Qt),jn[_t]=Mt?Ot?Un.dh:Vt:ne[0][o.cH]),qe&&G.css(jn),ne.css(Bn),Bn={},jn={},de=de||{x:!1,y:!1},e||t||Zt||tn||Re||xn||wn||On||Cn||Fn.c||nt||lt||je||Pe||Q||yt||zt||Ne||Re||yt||zt||r){var Qn="overflow",Vn=Qn+"-x",Xn=Qn+"-y",Yn="hidden",Jn="visible",Kn=z&&(C.x||C.y||Ht.w0&&(jn[qt]=Math.max(1,jn[qt]),jn[_t]=Math.max(1,jn[_t])),Mt&&re.css(Er),G.css(jn)}wn&&(Bn[qt]=Yt),!wn||E||rt||(Bn[Ut]="none"),ne.css(Bn),Bn={};var Hr=ir.getBoundingClientRect(),Wr={w:Math.max(ir[o.sW],lr[o.sW]),h:Math.max(ir[o.sH],lr[o.sH])};if(Kn&&ne.css(Qn,Qt),Hr.width!==n){var Lr=Hr.width,Pr=Hr.height,Fr=.001;Wr.w+=vi(Lr+Fr)-Lr,Wr.h+=vi(Pr+Fr)-Pr}Wr.c=t=Cr(Wr,he,r),he=Wr,e=Cr(hr={w:hn[o.cW],h:hn[o.cH]},fe),fe=hr,Ht={w:vn[o.oW],h:vn[o.oH]};var Nr={x:"v-s"===st.x,y:"v-s"===st.y},Dr={x:"v-h"===st.x,y:"v-h"===st.y},Rr={x:"s"===st.x,y:"s"===st.y},Br={x:Math.max(0,Math.round(100*(Wr.w-hr.w+(De?H:0)))/100),y:Math.max(0,Math.round(100*(Wr.h-hr.h+(De?k:0)))/100)},jr=Mt&&(0===Ht.w||0===Ht.h);jr&&(Br.x=0,Br.y=0);var qr={x:Br.x>0,y:Br.y>0},_r={x:qr.x,y:qr.y};(Nr.x||Dr.x)&&(_r.x=qr.y&&!Nr.y&&!Dr.y),(Nr.y||Dr.y)&&(_r.y=qr.x&&!Nr.x&&!Dr.x),_r.xs=!!_r.x&&(Rr.x||Nr.x),_r.ys=!!_r.y&&(Rr.y||Nr.y);var Jr={x:qr.x&&_r.xs,y:qr.y&&_r.ys},Kr=Ee;if(Br.c=Cr(Br,Ee,Jt,Kt,r),Ee=Br,qr.c=Cr(qr,de,Jt,Kt,r),de=qr,_r.c=Cr(_r,pe,Jt,Kt,r),pe=_r,C.x||C.y){var $r=r,ti={};if((qr.x||qr.y)&&(ti.w=C.y&&qr.y?Wr.w+O.y:Qt,ti.h=C.x&&qr.x?Wr.h+O.x:Qt,$r=br(ti,ve,r),ve=ti),qr.c||_r.c||Wr.c||Zt||xn||On||wn||Cn||nt){var ni="px solid transparent";Bn[Pt+ln]=Qt,Bn[Wt+ln]=Qt,C.x&&qr.x&&_r.xs?(Cn&&(Bn[Wt+Dt]=tt?Qt:O.x),Bn[Pt+Dt]=Cn||tt?Qt:O.x+ni):(ti.h=Qt,$r=!0,Bn[Pt+Dt]=Qt,Bn[Wt+Dt]=Qt),C.y&&qr.y&&_r.ys?(wn&&(Bn[Wt+rn]=tt?Qt:O.y),Bn[Pt+rn]=tt?Qt:O.y+ni):(ti.w=Qt,$r=!0,Bn[Pt+rn]=Qt,Bn[Wt+rn]=Qt)}if(tt&&(ti.w=Qt,ti.h=Qt,$r=!0),$r){var ri={};ri[qt]=_r.y?ti.w:Qt,ri[_t]=_r.x?ti.h:Qt,te===n&&(te=c($t+Nn+Gt),ee.prepend(te)),te.css(ri)}ne.css(Bn)}var ii={};qn={};if(e||qr.c||_r.c||Wr.c||lt||tn||nt||Zt||je||On){ii[ln]=Qt;var ai=function(){ii[Dt]=Qt,Tt.h=0},si=function(){ii[rn]=Qt,Tt.w=0};if(qr.x&&_r.xs?(ii[Vn]=Xt,tt?ai():(ii[Dt]=-(C.x?O.x:x.x),Tt.h=C.x?O.y:0)):(ii[Vn]=Qt,ai()),qr.y&&_r.ys?(ii[Xn]=Xt,tt?si():(ii[rn]=-(C.y?O.y:x.y),Tt.w=C.y?O.x:0)):(ii[Xn]=Qt,si()),(Ht.h-1,Ni=Pi.y>-1;(Fi||Ni)&&(Ni&&ee[an](Pi.y),Fi&&(F&&Je&&p.i?ee[on](0):ee[on](Pi.x)))}Le=Ai}else Mt||(F&&p.i&&C.y&&qr.x&&Je&&(u.l+=Tt.w),ee[on](u.l),ee[an](u.t));Zt&&c.isFunction(D)&&Mr(D,{isRTL:F,dir:It}),e&&c.isFunction(B)&&Mr(B,{width:fe.w,height:fe.h}),t&&c.isFunction(R)&&Mr(R,{width:he.w,height:he.h}),(qr.c||_r.c)&&c.isFunction(S)&&Mr(S,{x:qr.x,y:qr.y,xScrollable:_r.xs,yScrollable:_r.ys,clipped:_r.x||_r.y}),Br.c&&c.isFunction(T)&&Mr(T,{x:Br.x,y:Br.y})}St&&(qr.c||et.c)&&(et.f||oi(),C.y&&qr.x&&ne.css(Bt+qt,et.w+O.y),C.x&&qr.y&&ne.css(Bt+_t,et.h+O.x),et.c=!1),gr($),gr(K),c.isFunction(M)&&Mr(M,{forced:r})}}function mi(e,t){R=h.defaultOptions,g=h.nativeScrollbarStyling,x=c.extend(!0,{},h.nativeScrollbarSize),C=c.extend(!0,{},h.nativeScrollbarIsOverlaid),O=c.extend(!0,{},h.overlayScrollbarDummySize),p=c.extend(!0,{},h.rtlScrollBehavior),ui(c.extend(!0,{},R,t));var n,r=j.callbacks;if(C.x&&C.x&&!j.nativeScrollbarsOverlaid.initialize){var i=r.onInitializationWithdrawn;return c.isFunction(i)&&Mr(i),!1}if(w=h.cssCalc,m=h.msie,y=h.autoUpdateRecommended,M=h.supportTransition,S=h.supportTransform,A=h.supportPassiveEvents,T=h.supportResizeObserver,it=h.supportMutationObserver,z=h.restrictedMeasuring,Q=c(e.ownerDocument),U=c(Q[0].defaultView||Q[0].parentWindow),V=Q.find("html").first(),X=V.find("body").first(),Y=c(e),Mt=Y.is("textarea"),(St=Y.is("body"))&&((n={}).l=Math.max(Y[on](),V[on](),U[on]()),n.t=Math.max(Y[an](),V[an](),U[an]())),Mt){Y.wrap($t+xn+Gt),Y.addClass(Hn).addClass(_n),J=Y.parent();var a={};j.sizeAutoCapable||(a[qt]=Y.css(qt),a[_t]=Y.css(_t)),J.css(a).wrapInner($t+Fn+en+_n+Gt).wrapInner($t+Wn+en+_n+Gt).wrapInner($t+In+en+_n+Gt),ne=J.find(Zt+Fn).first(),ee=J.find(Zt+Wn).first(),Z=J.find(Zt+In).first(),re=c($t+kn+Gt),ne.prepend(re),Y.on(Xt,Br).on("drop",Nr).on("focus",Dr).on("focusout",Rr),m>9||!y?Y.on("input",Lr):Y.on(hn,Pr).on(vn,Fr)}else Y.addClass(wn),(J=Y).wrapInner($t+Fn+Gt).wrapInner($t+Wn+Gt).wrapInner($t+In+Gt),ne=J.find(Zt+Fn).first(),ee=J.find(Zt+Wn).first(),Z=J.find(Zt+In).first(),ne.on(pn,function(e){!0!==ke&&di((e=e.originalEvent||e).propertyName)&&yi(Vt)});if(Jr(),A?pr(ee,Xt,ti):ee.on(Xt,ti),g&&(C.x&&C.y?ee.addClass(Pn):ee.addClass(Ln)),it){var l,u=s.mO(),f=s.now();tt=new u(function(e){if(Ct&&!N){var t=!1;c.each(e,function(){var e=this,n=this.target,r=e.attributeName;if(t=r===o.c?li(e.oldValue,n.className):r!==o.s||e.oldValue!==n.style.cssText)return!1}),t&&bt.update(Vt)}}),nt=new u(function(e){if(Ct&&!N){for(var t=!1,n=0;ncr||!i?o():l=setTimeout(o,cr)}}})}St&&(V.addClass(gn),ee[on](n.l),ee[an](n.t)),$=c($t+"os-resize-observer-host"+Gt),J.prepend($),wr($,dr),dr(),bt.update(Vt),setTimeout(function(){M&&!Ot&&J.addClass(On)},333),Ct=!0;var v=r.onInitialized;return c.isFunction(v)&&Mr(v),Ct}}e[r]=function(e,t){if(0===arguments.length)return this;d();var r,i=[];return c.isPlainObject(t)?e&&e.length?e.length>1?(c.each(e,function(){(r=this)!==n&&i.push(m(r,t,f,h))}),i):m(e[0],t,f,h):m(e,t,f,h):e?e.length&&e.length>0?e.length>1?(c.each(e,function(){r=l.get(this),"!"===t?r!==n&&i.push(r):i.push(r)}),i):l.get(e[0]):l.get(e):void 0},e[r].globals=function(){d();var e=c.extend(!0,{},f);return delete e.msie,e},e[r].defaultOptions=function(e){d();var t=f.defaultOptions;if(e===n)return c.extend(!0,{},t);f.defaultOptions=c.extend(!0,{},t,e)}}(a,l,s,c),e.jQuery);return u&&u.fn&&(u.fn.overlayScrollbars=function(t){var n=this;return u.isPlainObject(t)?(u.each(n,function(){e[r](this,t)}),n):e[r](n,t)}),e[r]}); \ No newline at end of file +!function(t,e){"object"==typeof module&&"object"==typeof module.exports?module.exports=e(t,t.document,undefined):e(t,t.document,undefined)}("undefined"!=typeof window?window:this,function(t,e,n){"use strict";var r="OverlayScrollbars",i={o:"object",f:"function",a:"array",s:"string",b:"boolean",n:"number",u:"undefined",z:"null"},o={c:"class",s:"style",i:"id",oH:"offsetHeight",cH:"clientHeight",sH:"scrollHeight",oW:"offsetWidth",cW:"clientWidth",sW:"scrollWidth"},a={wW:function(){return t.innerWidth||e.documentElement[o.cW]||e.body[o.cW]},wH:function(){return t.innerHeight||e.documentElement[o.cH]||e.body[o.cH]},mO:function(){return t.MutationObserver||t.WebKitMutationObserver||t.WebkitMutationObserver||t.MozMutationObserver||n},rO:function(){return t.ResizeObserver||t.WebKitResizeObserver||t.WebkitResizeObserver||t.MozResizeObserver||n},rAF:function(){return t.requestAnimationFrame||t.webkitRequestAnimationFrame||t.mozRequestAnimationFrame||t.oRequestAnimationFrame||t.msRequestAnimationFrame||function(e){return t.setTimeout(e,1e3/60)}},cAF:function(){return t.cancelAnimationFrame||t.webkitCancelAnimationFrame||t.mozCancelAnimationFrame||t.oCancelAnimationFrame||t.msCancelAnimationFrame||function(e){return t.clearTimeout(e)}},now:function(){return Date.now()||(new Date).getTime()},stpP:function(t){t.stopPropagation?t.stopPropagation():t.cancelBubble=!0},prvD:function(t){t.preventDefault?t.preventDefault():t.returnValue=!1},page:function(t){var r="page",i="client",o="X",a="Y",s=((t=t.originalEvent||t).target||t.srcElement||e).ownerDocument||e,c=s.documentElement,l=s.body;if(t.touches!==n){var u=t.touches[0];return{x:u[r+o],y:u[r+a]}}return!t[r+o]&&t[i+o]&&null!=t[i+o]?{x:t[i+o]+(c&&c.scrollLeft||l&&l.scrollLeft||0)-(c&&c.clientLeft||l&&l.clientLeft||0),y:t[i+a]+(c&&c.scrollTop||l&&l.scrollTop||0)-(c&&c.clientTop||l&&l.clientTop||0)}:{x:t[r+o],y:t[r+a]}},mBtn:function(t){return t.which||t.button===n?t.which:1&t.button?1:2&t.button?3:4&t.button?2:0},bind:function(t,e){if(typeof t!==i.f)throw"Can't bind function!";var n=Array.prototype.slice.call(arguments,2),r=function(){},o=function(){return t.apply(this instanceof r?this:e,n.concat(Array.prototype.slice.call(arguments)))};return t.prototype&&(r.prototype=t.prototype),o.prototype=new r,o}},s=function(r){var o=/[^\x20\t\r\n\f]+/g,a=Object.prototype.toString,s=" ",c="",l=[],u={animationIterationCount:!0,columnCount:!0,fillOpacity:!0,flexGrow:!0,flexShrink:!0,fontWeight:!0,lineHeight:!0,opacity:!0,order:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},f={swing:function(t,e,n,r,i){return.5-Math.cos(t*Math.PI)/2},linear:function(t,e,n,r,i){return t},easeInQuad:function(t,e,n,r,i){return r*(e/=i)*e+n},easeOutQuad:function(t,e,n,r,i){return-r*(e/=i)*(e-2)+n},easeInOutQuad:function(t,e,n,r,i){return(e/=i/2)<1?r/2*e*e+n:-r/2*(--e*(e-2)-1)+n},easeInCubic:function(t,e,n,r,i){return r*(e/=i)*e*e+n},easeOutCubic:function(t,e,n,r,i){return r*((e=e/i-1)*e*e+1)+n},easeInOutCubic:function(t,e,n,r,i){return(e/=i/2)<1?r/2*e*e*e+n:r/2*((e-=2)*e*e+2)+n},easeInQuart:function(t,e,n,r,i){return r*(e/=i)*e*e*e+n},easeOutQuart:function(t,e,n,r,i){return-r*((e=e/i-1)*e*e*e-1)+n},easeInOutQuart:function(t,e,n,r,i){return(e/=i/2)<1?r/2*e*e*e*e+n:-r/2*((e-=2)*e*e*e-2)+n},easeInQuint:function(t,e,n,r,i){return r*(e/=i)*e*e*e*e+n},easeOutQuint:function(t,e,n,r,i){return r*((e=e/i-1)*e*e*e*e+1)+n},easeInOutQuint:function(t,e,n,r,i){return(e/=i/2)<1?r/2*e*e*e*e*e+n:r/2*((e-=2)*e*e*e*e+2)+n},easeInSine:function(t,e,n,r,i){return-r*Math.cos(e/i*(Math.PI/2))+r+n},easeOutSine:function(t,e,n,r,i){return r*Math.sin(e/i*(Math.PI/2))+n},easeInOutSine:function(t,e,n,r,i){return-r/2*(Math.cos(Math.PI*e/i)-1)+n},easeInExpo:function(t,e,n,r,i){return 0==e?n:r*Math.pow(2,10*(e/i-1))+n},easeOutExpo:function(t,e,n,r,i){return e==i?n+r:r*(1-Math.pow(2,-10*e/i))+n},easeInOutExpo:function(t,e,n,r,i){return 0==e?n:e==i?n+r:(e/=i/2)<1?r/2*Math.pow(2,10*(e-1))+n:r/2*(2-Math.pow(2,-10*--e))+n},easeInCirc:function(t,e,n,r,i){return-r*(Math.sqrt(1-(e/=i)*e)-1)+n},easeOutCirc:function(t,e,n,r,i){return r*Math.sqrt(1-(e=e/i-1)*e)+n},easeInOutCirc:function(t,e,n,r,i){return(e/=i/2)<1?-r/2*(Math.sqrt(1-e*e)-1)+n:r/2*(Math.sqrt(1-(e-=2)*e)+1)+n},easeInElastic:function(t,e,n,r,i){var o=1.70158,a=0,s=r;if(0==e)return n;if(1==(e/=i))return n+r;if(a||(a=.3*i),s0&&e-1 in t)}function M(t){return(t.match(o)||[]).join(s)}function O(t,n){for(var r=(t.parentNode||e).querySelectorAll(n)||[],i=r.length;i--;)if(r[i]==t)return!0;return!1}function C(t,e,n){p(n)===i.s?t.insertAdjacentHTML(e,n):n.nodeType?t.insertAdjacentElement(e,n):t.insertAdjacentElement(e,n[0])}function S(t,e,r){try{t.style[e]!==n&&(t.style[e]=A(e,r))}catch(i){}}function A(t,e){return u[t.toLowerCase()]||p(e)!==i.n||(e=e+="px"),e}function z(t,e){var n,r;!1!==e&&t.q.splice(0,1),t.q.length>0?(r=t.q[0],E(t.el,r.props,r.duration,r.easing,r.complete,!0)):(n=w(t,l))>-1&&l.splice(n,1)}function T(t,e,n){"scrollLeft"===e?t[e]=n:"scrollTop"===e?t[e]=n:S(t,e,n)}function E(t,e,n,i,o,a){var s,c,u,h,p,v,g={},b={},M=0,O=m(n);for(O?(i=n.easing,n.start,u=n.progress,h=n.step,p=n.specialEasing,o=n.complete,v=n.duration):v=n,p=p||{},v=v||400,i=i||"swing",a=a||!1;M0)I=r.now(),W=function(){for(s in C=r.now(),L=C-I,S=N.stop||L>=v,A=1-(Math.max(0,I+v-C)/v||0),b)E=g[s],H=b[s],k=(H-E)*f[p[s]||i](A,A*v,0,1,v)+E,T(t,s,k),d(h)&&h(k,{elem:t,prop:s,start:E,now:k,end:H,pos:A,options:{easing:i,speacialEasing:p,duration:v,complete:o,step:h},startTime:I});d(u)&&u({},A,Math.max(0,v-L)),S?(z(c),d(o)&&o()):N.frame=r.rAF()(W)},N.frame=r.rAF()(W);else{for(s in b)T(t,s,b[s]);z(c)}}}function H(t,e,n){for(var i,o,a,s=0;s0){if((o=i.q[0]).stop=!0,r.cAF()(o.frame),i.q.splice(0,1),n)for(a in o.props)T(t,a,o.props[a]);e?i.q=[]:z(i,!1)}break}}return x.prototype={each:function(t){return g(this,t)},append:function(t){return this.each(function(){C(this,"beforeend",t)})},prepend:function(t){return this.each(function(){C(this,"afterbegin",t)})},before:function(t){return this.each(function(){C(this,"beforebegin",t)})},after:function(t){return this.each(function(){C(this,"afterend",t)})},hover:function(t,e){return this.on("mouseenter",t).on("mouseleave",e||t)},first:function(){return new x(this[0])},last:function(){return new x(this[this.length-1])},find:function(t){var e,n=[];return this.each(function(){var r=this.querySelectorAll(t);for(e=0;e-1)return!0;return!1},addClass:function(t){var e,r,i,a,c,l,u=null,f=0,h=0;if(t)for(e=t.match(o)||[];r=this[f++];)if(u===n&&(u=r.classList!==n),u)for(;c=e[h++];)r.classList.add(c);else if(a=r.className,i=1===r.nodeType&&s+M(a)+s){for(;c=e[h++];)i.indexOf(s+c+s)<0&&(i+=c+s);a!==(l=M(i))&&(r.className=l)}return this},removeClass:function(t){var e,r,i,a,c,l,u=null,f=0,h=0;if(t)for(e=t.match(o)||[];r=this[f++];)if(u===n&&(u=r.classList!==n),u)for(;c=e[h++];)r.classList.remove(c);else if(a=r.className,i=1===r.nodeType&&s+M(a)+s){for(;c=e[h++];)for(;i.indexOf(s+c+s)>-1;)i=i.replace(s+c+s,s);a!==(l=M(i))&&(r.className=l)}return this},remove:function(){return this.each(function(){var t=this;null!=t.parentNode&&t.parentNode.removeChild(t)})},offset:function(){var n=this[0].getBoundingClientRect(),r=t.pageXOffset||e.documentElement.scrollLeft,i=t.pageYOffset||e.documentElement.scrollTop;return{top:n.top+i,left:n.left+r}},position:function(){var t=this[0];return{top:t.offsetTop,left:t.offsetLeft}},css:function(e,r){var o,a;return p(e)===i.s?r===n?(o=this[0],t.getComputedStyle?t.getComputedStyle(o,null).getPropertyValue(e):o.currentStyle[e]):this.each(function(){S(this,e,r)}):this.each(function(){for(a in e)S(this,a,e[a])})},unwrap:function(){var t,e,n,r=[];for(this.each(function(){n=this.parentNode,-1===w(n,r)&&r.push(n)}),t=0;t0;)i=i.childNodes[0];for(e=0;n.length-e;i.firstChild===n[0]&&e++)i.appendChild(n[e]);var s=a?a.nextSibling:o.firstChild;return o.insertBefore(r,s),this},wrapInner:function(t){return this.each(function(){var e=new x(this),n=e.contents();n.length?n.wrapAll(t):e.append(t)})},wrap:function(t){return this.each(function(){new x(this).wrapAll(t)})},contents:function(){var t,e,n=[];return this.each(function(){for(t=this.childNodes,e=0;e0?"\r\nValid strings are: [ "+H.join(", ").split(p).join(", ")+" ].":"")),delete t[s]}}};return l(s,e,a),o?c.extend(!0,a,s):!c.isEmptyObject(s)&&n&&console.warn("The following options are discarded due to invalidity:\r\n"+JSON.stringify(s,null,2)),a}});function O(){l||(l=new C(M.d)),u||(u=new S(l))}function C(r){var i=this,l="overflow",u="hidden",f="scroll",h=c("body"),p=c('
'),d=p[0],v=c(p.children("div").first()),y=d[o.oH];h.append(p),0===y&&p.hide().show();var m,w,g,x,b,M,O,C,S,A=E(d),z={x:0===A.x,y:0===A.y};function T(t){var r=!1,i="Webkit Moz ms O".split(" "),o=e.createElement("div"),a=null,s=0;if(t=t.toLowerCase(),o.style[t]!==n&&(r=!0),!r)for(a=t.charAt(0).toUpperCase()+t.substr(1);s0?C=S(m[g](x+5,m[w](".",x)),10):b>0?C=S(m[g](O+3,m[w](".",O)),10):M>0&&(C=S(m[g](M+5,m[w](".",M)),10)),C),cssCalc:function(){var t,n,r=e.createElement("div"),i=["calc","-webkit-calc","-moz-calc","-o-calc"];for(t=0;t0){var t=a.wW(),u=a.wH(),f=t-e,d=u-n;if(0===f&&0===d)return;var v=Math.round(t/(e/100)),y=Math.round(u/(n/100)),m=Math.abs(f),w=Math.abs(d),g=Math.abs(v),x=Math.abs(y),b=l(),M=m>2&&w>2,O=!o(g,x);!(M&&O&&(b!==r&&r>0))||(h.append(p),i.nativeScrollbarSize=E(p[0]),p.remove(),c.each(s.all(),function(){s.has(this)&&s.get(this).update("zoom")})),e=t,n=u,r=b}})}function o(t,e){var n=Math.abs(t),r=Math.abs(e);return!(n===r||n+1===r||n-1===r)}function l(){var e=t.screen.deviceXDPI||0,n=t.screen.logicalXDPI||1;return t.devicePixelRatio||e/n}}()}function S(t){var e,r=this,i="autoUpdate",o=i+"Interval",s=[],l=[],u=!1,f=33,h=f,p=a.now(),d=function(){if(s.length>0&&u){e=a.rAF()(function(){d()});var t=a.now(),r=t-p;if(r>h){p=t-r%h;for(var c=f,v=0;vg&&(y.update("auto"),l[v]=new Date(x+=g)),c=Math.max(1,Math.min(c,g))}}h=c}}else h=f};r.add=function(e){-1===c.inArray(e,s)&&(s.push(e),l.push(a.now()),s.length>0&&!u&&(u=!0,t.autoUpdateLoop=u,d()))},r.remove=function(r){var i=c.inArray(r,s);i>-1&&(l.splice(i,1),s.splice(i,1),0===s.length&&u&&(u=!1,t.autoUpdateLoop=u,e!==n&&(a.cAF()(e),e=-1)))}}function A(e,l,u,f){if(ni(e)){if(s.has(e)){var h=s.get(e);return h.options(l),h}var p,d,v,y,m,w,g,x,b,O,C,S,A,z,T,E,H,k,I,W,L,P,N,R,j,D,F,B,q,_,U,Q,V,X,Y,K,$,G,J,Z,tt,et,nt,rt,it,ot,at,st,ct,lt,ut,ft,ht,pt,dt,vt,yt,mt,wt,gt,xt,bt,Mt,Ot,Ct,St,At,zt,Tt,Et,Ht,kt,It,Wt,Lt,Pt,Nt,Rt,jt,Dt,Ft,Bt,qt,_t,Ut,Qt,Vt,Xt,Yt,Kt,$t,Gt,Jt,Zt,te,ee,ne,re,ie,oe,ae,se,ce,le,ue,fe,he,pe,de,ve,ye,me,we,ge,xe,be,Me,Oe,Ce=new t[r],Se={},Ae={},ze={},Te={},Ee={},He=175,ke="-hidden",Ie="margin-",We="padding-",Le="border-",Pe="top",Ne="right",Re="bottom",je="left",De="min-",Fe="max-",Be="width",qe="height",_e="float",Ue="",Qe="auto",Ve="scroll",Xe="100%",Ye="x",Ke="y",$e=".",Ge=" ",Je="scrollbar",Ze="-horizontal",tn="-vertical",en=Ve+"Left",nn=Ve+"Top",rn="mousedown touchstart",on="mouseup touchend",an="mousemove touchmove",sn="mouseenter",cn="mouseleave",ln="keydown",un="keyup",fn="selectstart",hn="transitionend webkitTransitionEnd oTransitionEnd",pn="__overlayScrollbarsRO__",dn="os-",vn=dn+"html",yn=dn+"host",mn=yn+"-textarea",wn=yn+"-"+Je+Ze+ke,gn=yn+"-"+Je+tn+ke,xn=yn+"-transition",bn=yn+"-rtl",Mn=yn+"-resize-disabled",On=yn+"-scrolling",Cn=yn+"-overflow",Sn=Cn+"-x",An=Cn+"-y",zn=dn+"textarea",Tn=zn+"-cover",En=dn+"padding",Hn=dn+"viewport",kn=Hn+"-native-scrollbars-invisible",In=Hn+"-native-scrollbars-overlaid",Wn=dn+"content",Ln=dn+"content-arrange",Pn=dn+"content-glue",Nn=dn+"size-auto-observer",Rn=dn+"resize-observer",jn=dn+"resize-observer-item",Dn=jn+"-final",Fn=dn+"text-inherit",Bn=dn+Je,qn=Bn+"-track",_n=qn+"-off",Un=Bn+"-handle",Qn=Un+"-off",Vn=Bn+"-unusable",Xn=Bn+"-"+Qe+ke,Yn=Bn+"-corner",Kn=Yn+"-resize",$n=Kn+"-both",Gn=Kn+Ze,Jn=Kn+tn,Zn=Bn+Ze,tr=Bn+tn,er=dn+"dragging",nr=dn+"theme-none",rr={},ir=33,or=[],ar=11,sr=[112,113,114,115,116,117,118,119,120,121,123,33,34,37,38,39,40,16,17,18,19,20,144],cr=[],lr={},ur={};if(Ce.sleep=function(){F=!0},Ce.update=function(t){var e,n,r="zoom"===t,i="img",o="load";t===Qe?(e=Br(),n=Fr(),(e||n)&&Ur(!1,n)):r?Ur(!0,!0):(t=F||t,F=!1,Ur(!1,!1,t)),E||r||ot.find(i).each(function(t,e){-1===c.inArray(e,or)&&(e=c(e)).off(o,Nr).on(o,Nr)})},Ce.options=function(t,e){if(c.isEmptyObject(t)||!c.isPlainObject(t)){if(yi(t)===i.s){if(arguments.length>=2){var n={};return hi(n,t,e),Qr(n),void Ur()}return fi(_,t)}return _}Qr(t);var r=F||!1;F=!1,Ur(),F=r},Ce.destroy=function(){T=!0,f.remove(Ce),wr(),dr(tt),I&&dr(Z),xi(tt),et!==n&&xi(et),it!==n&&xi(it),I&&xi(Z),C?(hr(J,an,Mr),hr(J,sn,xr),hr(J,cn,br)):J.off(an,Mr).off(sn,xr).off(cn,br),xi(ct),xi(ft),st&&xi(st),xe||Lr(),ot.contents().unwrap().unwrap().unwrap(),H&&gi(K,vn),E?(G.off(Ve,kr).off("drop",Tr).off("focus",Er).off("focusout",Hr),m>9||!y?G.off("input",Sr):G.off(ln,Ar).off(un,zr),xi(at),gi(G,zn+Ge+Fn).unwrap().removeAttr(o.s),xi(J)):(gi(G,yn),gi(J,[yn,Mn,bn,wn,gn,xn,On,Cn,Sn,An,nr,Zt].join(Ge)));for(var t=0;t0)e.x=t[0],e.y=t[1];else if(yi(t)===i.s||yi(t)===i.n)e.x=t,e.y=t;else if(yi(t)===i.o){for(var n in t=mi({},t),m=0,t)t.hasOwnProperty(n)&&(m>2&&delete t[n],m++);var r=function(e){var n=e?w:g;for(m=0;m2){var y=r.substr(0,2);for(m=0;m/g,(p?"-":Ue)+Xe))[d](/px/g,Ue))[d](/%/g,f+u*(h&&v.n?-1:1)/100))[d](/vw/g,f+Te.w))[d](/vh/g,f+Te.h),a=ii(t.parseFloat(t.eval(r)).toFixed())}else yi(r)===i.n&&(a=r);if(!isNaN(a)&&a!==n&&yi(a)===i.n){var w=Jt&&h,g=l*(w&&v.n?-1:1),b=w&&v.i,M=w&&v.n;switch(g=b?u-g:g,o){case"+=":s=g+a;break;case"-=":s=g-a;break;case"*=":s=g*a;break;case"/=":s=g/a;break;default:s=a}b&&(s=u-s),M&&(s*=-1),h&&v.n?(s=Math.max(u,s),s=Math.min(0,s)):(s=Math.min(u,s),s=Math.max(0,s)),s===l&&(s=n)}return s};if(W||L){var j=W?I:c(I);if(0===j.length)return;if(k){var F,B,q,_=e.axis,U=e.block,Q=yi(U),V=e.margin,X=yi(V);if(Q===i.s)U=[U,U];else if(Q===i.a)if((B=U.length)>2||B<1)U=n;else{for(F=!0,1===B&&(U[1]=S),m=0;m=$[e.lt]&&K[e.lt]+ft[e._wh]<=$[e.lt]+Te[e._wh],et[e.xy]=ft[e._wh]i:r0||M){var vt={};if(pt&&(vt[en]=b.x),dt&&(vt[nn]=b.y),M)rt.animate(vt,r);else{var yt={duration:r,complete:s};if(yi(a)===i.a){var mt={};mt[en]=a[0],mt[nn]=a[1],yt.specialEasing=mt}else yt.easing=a;rt.animate(vt,yt)}}else pt&&rt[en](b.x),dt&&rt[nn](b.y)},Ce.scrollStop=function(t,e,n){rt.stop(t,e,n)},Ce.getElements=function(){return{target:G[0],host:J[0],padding:nt[0],viewport:rt[0],content:ot[0],scrollbarHorizontal:{scrollbar:ct[0],track:lt[0],handle:ut[0]},scrollbarVertical:{scrollbar:ft[0],track:ht[0],handle:pt[0]},scrollbarCorner:st}},Ce.getState=function(t){var e=function(t){if(!c.isPlainObject(t))return t;var e=mi(!0,{},t),n=function(t,n){e.hasOwnProperty(t)&&(e[n]=e[t],delete e[t])};return n("w",Be),n("h",qe),delete e.c,e},n={sleeping:e(F)||!1,autoUpdate:e(!ae),widthAuto:e(gt),heightAuto:e(xt),padding:e(Ot),overflowAmount:e(It),hideOverflow:e(wt),hasOverflow:e(mt),contentScrollSize:e(vt),viewportSize:e(Te),hostSize:e(dt)};return yi(t)===i.s?fi(n,t):n},bi(e,l))return s.add(e,Ce),Ce;Ce=n}function fr(t,e,n){for(var r=e.split(Ge),i=0;i9||!y){t.prepend(ui(Rn,ui({className:jn,dir:"ltr"},ui(jn,ui(Dn))+ui(jn,ui({className:Dn,style:"width: 200%; height: 200%"})))));var p,d,w,g,x=t[0][l][0][l][0],b=c(x[l][1]),M=c(x[l][0]),O=c(M[0][l][0]),C=x[o.oW],A=x[o.oH],z=2,T=u.nativeScrollbarSize,E=function(){M[en](n)[nn](n),b[en](n)[nn](n)},H=function(){d=0,p&&(C=w,A=g,f())},k=function(t){return w=x[o.oW],g=x[o.oH],p=w!=C||g!=A,t&&p&&!d?(a.cAF()(d),d=a.rAF()(H)):t||H(),E(),t&&(a.prvD(t),a.stpP(t)),!1},I={},W={};W[Pe]=-(T.y+1)*z,W[Ne]=T.x*-z,W[Re]=T.y*-z,W[je]=-(T.x+1)*z,c(x).css(W),M.on(Ve,k),b.on(Ve,k),t.on(s,function(){k(!1)}),I[Be]=n,I[qe]=n,O.css(I),E()}else{var L=Y[0],P=L.attachEvent,N=!1!==m;if(P)t.prepend(ui(Rn)),li(t,$e+Rn)[0].attachEvent("onresize",f);else{var R=L.createElement(i.o);R.setAttribute("tabindex","-1"),R.setAttribute(o.c,Rn),R.onload=function(){var t=this.contentDocument.defaultView;t.addEventListener("resize",f),t.document.documentElement.style.display="none"},R.type="text/html",N&&t.prepend(R),R.data="about:blank",N||t.prepend(R),t.on(s,f)}}if(t[0]===tt[0]){var j=function(){var e=J.css("direction"),r={},i=0,o=!1;return e!==zt&&("ltr"===e?(r[je]=0,r[Ne]=Qe,i=n):(r[je]=Qe,r[Ne]=0,i=v.n?-n:v.i?0:n),tt.children().first().css(r),t[en](i)[nn](n),zt=e,o=!0),o};j(),t.on(Ve,function(t){return j()&&Ur(),a.prvD(t),a.stpP(t),!1})}}function dr(t){if(S){var e=t.contents()[0];e[pn].disconnect(),delete e[pn]}else xi(t.children($e+Rn).first())}function vr(t){if(t!==n&&S){var e=t.contents()[0];e[pn].unobserve(e)}}function yr(t){if(t!==n&&S){var e=t.contents()[0];e[pn].observe(e)}}function mr(){se&&!ae&&(ie.observe(J[0],{attributes:!0,attributeOldValue:!0,attributeFilter:[o.i,o.c,o.s]}),oe.observe(E?G[0]:ot[0],{attributes:!0,attributeOldValue:!0,subtree:!E,childList:!E,characterData:!E,attributeFilter:E?["wrap","cols","rows"]:[o.i,o.c,o.s]}),ae=!0)}function wr(){se&&ae&&(ie.disconnect(),oe.disconnect(),ae=!1)}function gr(){if(!F){var t=tt[0],e={w:t[o.sW],h:t[o.sH]};if(z){var n=di(e,Vt);Vt=e,n&&Ur(!0,!1)}else Vt=e}}function xr(){ye&&Kr(!0)}function br(){ye&&!$.hasClass(er)&&Kr(!1)}function Mr(){ve&&(Kr(!0),clearTimeout(fe),fe=setTimeout(function(){ve&&Kr(!1)},100))}function Or(t){var e=U.callbacks;F||(B!==n?clearTimeout(B):((de||ve)&&Kr(!0),si()||J.addClass(On),ti(e.onScrollStart,t)),Gr(!0,rt[en]()),Gr(!1,rt[nn]()),ti(e.onScroll,t),B=setTimeout(function(){Cr(),ti(e.onScrollStop,t)},He))}function Cr(){clearTimeout(B),B=n,(de||ve)&&Kr(!1),si()||J.removeClass(On)}function Sr(){_r(),Ce.update(Qe)}function Ar(t){var e=t.keyCode;if(!ai(e)){if(0===cr.length){var n=function(){_r(),Ce.update(Qe)};n(),ce=setInterval(n,1e3/60)}-1===c.inArray(e,cr)&&cr.push(e)}}function zr(t){var e=t.keyCode;if(!ai(e)){var n=c.inArray(e,cr);n>-1&&cr.splice(n,1),0===cr.length&&(_r(),Ce.update(Qe),clearInterval(ce))}}function Tr(){setTimeout(function(){_r(),Ce.update(Qe)},50)}function Er(){le=!0}function Hr(){le=!1,clearInterval(ce),cr=[],_r(),Ce.update(Qe)}function kr(t){return G[en](v.i&&Jt?9999999:0),G[nn](0),a.prvD(t),a.stpP(t),!1}function Ir(t){if(!F){var e=(t.originalEvent||t).touches!==n;(1===a.mBtn(t)||e)&&(ae&&(ge=!0,wr()),lr=a.page(t),ur.w=J[0][o.oW]-(k?0:W),ur.h=J[0][o.oH]-(k?0:L),Y.on(fn,Pr).on(an,Wr).on(on,Lr),$.addClass(er),st.setCapture&&st.setCapture(),a.prvD(t),a.stpP(t))}}function Wr(t){var e=a.page(t),n={};(Me||be)&&(n[Be]=ur.w+e.x-lr.x),(Oe||be)&&(n[qe]=ur.h+e.y-lr.y),J.css(n),a.stpP(t)}function Lr(t){var e=t!==n;Y.off(fn,Pr).off(an,Wr).off(on,Lr),$.removeClass(er),st.releaseCapture&&st.releaseCapture(),e&&(ge&&mr(),Ce.update(Qe)),ge=!1}function Pr(t){return a.prvD(t),!1}function Nr(){Ur()}function Rr(){var t={};return H&&it&&(t.w=ii(it.css(De+Be)),t.h=ii(it.css(De+qe)),t.c=di(t,re),t.f=!0),re=t,t.c}function jr(t,e){var r=e!==n&&null!==e?e.split(Ge):Ue,i=t!==n&&null!==t?t.split(Ge):Ue;if(r===Ue&&i===Ue)return!1;var o,a,s,l,u=ri(i,r),f=!1,h=te!==n&&null!==te?te.split(Ge):[Ue],p=Zt!==n&&null!==Zt?Zt.split(Ge):[Ue],d=c.inArray(nr,u),v=u[o];for(d>-1&&u.splice(d,1),o=0;o0&&z&&i-Q0?ft:nr)),se&&(!0===oe?(wr(),f.add(Ce)):null===oe&&y?(wr(),f.add(Ce)):(f.remove(Ce),mr())),Qt)if(Ut)if(et===n&&(et=c(ui(Pn)),nt.before(et)),I)Z.show();else{Z=c(ui(Nn)),et.before(Z);var ze={w:-1,h:-1};pr(Z,function(){var t={w:Z[0][o.oW],h:Z[0][o.oH]};di(t,ze)&&(z&&xt&&t.h>0||gt&&t.w>0?Ur():(z&&!xt&&0===t.h||!gt&&0===t.w)&&Ur()),ze=t}),I=!0,null!==g&&Z.css(qe,g+"(100% + 1px)")}else I&&Z.hide();r&&(tt.find("*").trigger(Ve),I&&Z.find("*").trigger(Ve));var He,ke=J.css("direction"),$e=pi(ke,At,r),Je=J.css("box-sizing"),Ze=pi(Je,Mt,r),tn={c:r,t:ii(J.css(We+Pe)),r:ii(J.css(We+Ne)),b:ii(J.css(We+Re)),l:ii(J.css(We+je))};try{He=I?Z[0].getBoundingClientRect():null}catch(Fi){return}k="border-box"===Je;var on=(D="rtl"===ke)?je:Ne,ln=D?Ne:je,un=J[0],fn=nt[0],hn=!1,pn=!(!I||"none"===J.css(_e))&&(0===Math.round(He.right-He.left)&&(!!Ft||un[o.cW]-W>0));if(Ut&&!pn){var dn=un[o.oW],vn=et.css(Be);et.css(Be,Qe);var yn=un[o.oW];et.css(Be,vn),(hn=dn!==yn)||(et.css(Be,dn+1),yn=un[o.oW],et.css(Be,vn),hn=dn!==yn)}var mn=(pn||hn)&&Ut,wn=pi(mn,gt,r),gn=!mn&>,xn=!!I&&0===Math.round(He.bottom-He.top),zn=pi(xn,xt,r),Tn=!xn&&xt,En="-"+Be,Hn=mn&&k||!k,kn=xn&&k||!k,In={c:r,t:kn?ii(J.css(Le+Pe+En)):0,r:Hn?ii(J.css(Le+Ne+En)):0,b:kn?ii(J.css(Le+Re+En)):0,l:Hn?ii(J.css(Le+je+En)):0},Wn={c:r,t:ii(J.css(Ie+Pe)),r:ii(J.css(Ie+Ne)),b:ii(J.css(Ie+Re)),l:ii(J.css(Ie+je))},Rn={h:String(J.css(Fe+qe)),w:String(J.css(Fe+Be))},jn={},Dn={};if(W=tn.l+tn.r,L=tn.t+tn.b,tn.c=vi(tn,Ot),P=In.l+In.r,N=In.t+In.b,In.c=vi(In,Ct),R=Wn.l+Wn.r,j=Wn.t+Wn.b,Wn.c=vi(Wn,St),Rn.ih=ii(Rn.h),Rn.iw=ii(Rn.w),Rn.ch=Rn.h.indexOf("px")>-1,Rn.cw=Rn.w.indexOf("px")>-1,Rn.c=di(Rn,bt,r),At=ke,Mt=Je,gt=mn,xt=xn,Ot=tn,Ct=In,St=Wn,bt=Rn,$e&&I&&Z.css(_e,ln),tn.c||$e||Bt||wn||zn||Ze||Qt){var Fn={},Bn={};ei(Dn,Ie,[-tn.t,-tn.r,-tn.b,-tn.l]),Ft?(ei(Fn,Ue,[tn.t,tn.r,tn.b,tn.l]),ei(E?Bn:jn,We)):(ei(Fn,Ue),ei(E?Bn:jn,We,[tn.t,tn.r,tn.b,tn.l])),nt.css(Fn),G.css(Bn)}Te={w:fn[o.oW],h:fn[o.oH]};var qn=!!E&&_r();if(xn&&(zn||Bt||Ze||Rn.c||tn.c||In.c)?(Rn.cw&&(jn[Fe+qe]=Rn.ch?Rn.ih-(Ft?L:0)+(k?-N:L):Ue),jn[qe]=Qe):(zn||Bt)&&(jn[Fe+qe]=Ue,jn[qe]=Xe),mn&&(wn||Bt||Ze||Rn.c||tn.c||In.c||$e)?(Rn.cw&&(jn[Fe+Be]=Rn.cw?Rn.iw-(Ft?W:0)+(k?-P:W)+(p.y?d.y:0):Ue),jn[Be]=Qe,Dn[Fe+Be]=Xe):(wn||Bt)&&(jn[Fe+Be]=Ue,jn[Be]=Xe,jn[_e]=Ue,Dn[Fe+Be]=Ue),mn&&(Rn.cw||(jn[Fe+Be]=Ue),Dn[Be]=E&&fe?qn.dw:Qe,jn[Be]=Qe,jn[_e]=ln),xn&&(Rn.ch||(jn[Fe+qe]=Ue),Dn[qe]=E?ge?qn.dh:Qe:ot[0][o.cH]),Ut&&et.css(Dn),ot.css(jn),jn={},Dn={},mt=mt||{x:!1,y:!1},t||e||$e||Ze||Bt||wn||mn||zn||xn||Rn.c||ie||ue||_t||zt||X||we||Ae||Dt||Bt||we||Ae||r){var _n="overflow",Un=_n+"-x",Qn=_n+"-y",Vn="hidden",Xn="visible",Yn=A&&(p.x||p.y||Te.w0&&(Dn[Be]=Math.max(1,Dn[Be]),Dn[qe]=Math.max(1,Dn[qe])),E&&at.css(Cr),et.css(Dn)}mn&&(jn[Be]=Xe),!mn||k||ae||(jn[_e]="none"),ot.css(jn),jn={};var Sr=or.getBoundingClientRect(),Ar={w:Math.max(or[o.sW],ar[o.sW]),h:Math.max(or[o.sH],ar[o.sH])};if(Yn&&ot.css(_n,Ue),Sr.width){var zr=Sr.width,Tr=Sr.height,Er=.001;Ar.w+=ii(zr+Er)-zr,Ar.h+=ii(Tr+Er)-Tr}Ar.c=e=di(Ar,vt,r),vt=Ar,t=di(ur={w:un[o.cW],h:un[o.cH]},dt),dt=ur,Te={w:fn[o.oW],h:fn[o.oH]};var Hr={x:"v-s"===ce.x,y:"v-s"===ce.y},kr={x:"v-h"===ce.x,y:"v-h"===ce.y},Wr={x:"s"===ce.x,y:"s"===ce.y},Lr={x:Math.max(0,Math.round(100*(Ar.w-ur.w+(Ft?W:0)))/100),y:Math.max(0,Math.round(100*(Ar.h-ur.h+(Ft?L:0)))/100)},Pr=E&&(0===Te.w||0===Te.h);Pr&&(Lr.x=0,Lr.y=0);var Nr={x:Lr.x>0,y:Lr.y>0},jr={x:Nr.x,y:Nr.y};(Hr.x||kr.x)&&(jr.x=Nr.y&&!Hr.y&&!kr.y),(Hr.y||kr.y)&&(jr.y=Nr.x&&!Hr.x&&!kr.x),jr.xs=!!jr.x&&(Wr.x||Hr.x),jr.ys=!!jr.y&&(Wr.y||Hr.y);var Dr={x:Nr.x&&jr.xs,y:Nr.y&&jr.ys},Fr=It;if(Lr.c=di(Lr,It,Ye,Ke,r),It=Lr,Nr.c=di(Nr,mt,Ye,Ke,r),mt=Nr,jr.c=di(jr,wt,Ye,Ke,r),wt=jr,p.x||p.y){var Br=r,qr={};if((Nr.x||Nr.y)&&(qr.w=p.y&&Nr.y?Ar.w+d.y:Ue,qr.h=p.x&&Nr.x?Ar.h+d.x:Ue,Br=pi(qr,yt,r),yt=qr),Nr.c||jr.c||Ar.c||$e||wn||zn||mn||xn||ie){var Qr="px solid transparent";jn[Le+ln]=Ue,jn[Ie+ln]=Ue,p.x&&Nr.x&&jr.xs?(xn&&(jn[Ie+Re]=Vt?Ue:d.x),jn[Le+Re]=xn||Vt?Ue:d.x+Qr):(qr.h=Ue,Br=!0,jn[Le+Re]=Ue,jn[Ie+Re]=Ue),p.y&&Nr.y&&jr.ys?(mn&&(jn[Ie+on]=Vt?Ue:d.y),jn[Le+on]=Vt?Ue:d.y+Qr):(qr.w=Ue,Br=!0,jn[Le+on]=Ue,jn[Ie+on]=Ue)}if(Vt&&(qr.w=Ue,qr.h=Ue,Br=!0),Br){var Vr={};Vr[Be]=jr.y?qr.w:Ue,Vr[qe]=jr.x?qr.h:Ue,it===n&&(it=c(ui(Ln)),rt.prepend(it)),it.css(Vr)}ot.css(jn)}var Xr={};Fn={};if(t||Nr.c||jr.c||Ar.c||ue||Ze||ie||$e||_t||zn){Xr[ln]=Ue;var Zr=function(){Xr[Re]=Ue,Se.h=0},ni=function(){Xr[on]=Ue,Se.w=0};if(Nr.x&&jr.xs?(Xr[Un]=Ve,Vt?Zr():(Xr[Re]=-(p.x?d.x:x.x),Se.h=p.x?d.y:0)):(Xr[Un]=Ue,Zr()),Nr.y&&jr.ys?(Xr[Qn]=Ve,Vt?ni():(Xr[on]=-(p.y?d.y:x.y),Se.w=p.y?d.x:0)):(Xr[Qn]=Ue,ni()),(Te.h-1,Di=Ri.y>-1;(ji||Di)&&(Di&&rt[nn](Ri.y),ji&&(D&&Jt&&v.i?rt[en](0):rt[en](Ri.x)))}Rt=Ti}else E||(D&&v.i&&p.y&&Nr.x&&Jt&&(l.l+=Se.w||0),rt[en](l.l),rt[nn](l.t));$e&&ti(T,{isRTL:D,dir:ke}),t&&ti(q,{width:dt.w,height:dt.h}),e&&ti(B,{width:vt.w,height:vt.h}),(Nr.c||jr.c)&&ti(O,{x:Nr.x,y:Nr.y,xScrollable:jr.xs,yScrollable:jr.ys,clipped:jr.x||jr.y}),Lr.c&&ti(S,{x:Lr.x,y:Lr.y})}H&&(Nr.c||re.c)&&(re.f||Rr(),p.y&&Nr.x&&ot.css(De+Be,re.w+d.y),p.x&&Nr.y&&ot.css(De+qe,re.h+d.x),re.c=!1),yr(tt),yr(Z),ti(M,{forced:r})}}function Qr(t){_=mi(!0,{},_,M.v(t,M.t,!0)),U=mi(!0,{},U,M.v(t,M.t,!1,!0))}function Vr(){ct=c(ui(Bn+Ge+Zn)),lt=c(ui(qn)),ut=c(ui(Un)),ft=c(ui(Bn+Ge+tr)),ht=c(ui(qn)),pt=c(ui(Un)),ct.append(lt),lt.append(ut),ft.append(ht),ht.append(pt),nt.after(ft),nt.after(ct),b&&(ct.on(hn,function(t){t.target===ct[0]&&($r(!0),Gr(!0,rt[en]()))}),ft.on(hn,function(t){t.target===ft[0]&&($r(!1),Gr(!1,rt[nn]()))})),Xr(!0),Xr(!1),st=c(ui(Yn)),J.append(st)}function Xr(t){var e,r,i,o=Zr(t),s=o.xy,c=Ve+o.LT,l="active",u=1,f=function(){u=.5},h=function(){u=1},p=function(n){var i=o.i.tl,l=o.i.hl,u=o.i.ms*((l/2+a.page(n)[s]-r-l/2)/(i-l));u=isFinite(u)?u:0,D&&t&&(v.n||!v.n&&!v.i)&&(u*=-1),rt[c](e+u),C||a.prvD(n)},d=function(t){t=t||t.originalEvent,gi($,er),gi(o.h,l),gi(o.t,l),gi(o.s,l),C?(hr(Y,an,p),hr(Y,on,d),hr(Y,ln,y),hr(Y,un,m)):Y.off(an,p).off(on,d).off(ln,y).off(un,m),Y.off(fn,Pr),h(),e=n,r=n,i!==n&&(Ce.scrollStop(),clearTimeout(i),i=n);var a=J[0].getBoundingClientRect();t.clientX>=a.left&&t.clientX<=a.right&&t.clientY>=a.top&&t.clientY<=a.bottom||br(),(de||ve)&&Kr(!1)},y=function(t){16==t.keyCode&&f()},m=function(t){16==t.keyCode&&h()};o.h.on(rn,function(i){if(!F){var u=(i.originalEvent||i).touches!==n;si()||!$t||u&&!me||(1===a.mBtn(i)||u)&&(e=(e=rt[c]())===n?0:e,(D&&t&&!v.n||!D)&&(e=e<0?0:e),r=a.page(i)[s],wi($,er),wi(o.h,l),wi(o.s,l),C?(fr(Y,an,p),fr(Y,on,d)):Y.on(an,p).on(on,d),Y.on(fn,Pr),a.prvD(i))}}),o.t.on(rn,function(e){if(!F){var c=(e.originalEvent||e).touches!==n;if(!si()&&Kt&&(!c||me)&&(1===a.mBtn(e)||c)){var h,p=Te[o._wh],w=o.t.offset()[o.lt],g=!0;e.shiftKey&&f();var x=function(){var e=o.i.ho,a=o.i.hl,s=r-w,c=200*u,l=g?Math.max(333,c):c,f={},d=D&&t&&(!v.i&&!v.n||Jt),y=e>s;d&&(y=e=s;d&&(m=h?e+a>=s:e<=s),m?(clearTimeout(i),Ce.scrollStop(),i=n):i=setTimeout(x,l),g=!1};r=a.page(e)[s],wi($,er),wi(o.t,l),wi(o.s,l),C?(fr(Y,on,d),fr(Y,ln,y),fr(Y,un,m)):Y.on(on,d).on(ln,y).on(un,m),Y.on(fn,Pr),x(),a.prvD(e)}}}).hover(function(){(de||ve)&&(we=!0,Kr(!0))},function(){(de||ve)&&(we=!1,Kr(!1))}),o.s.on(rn,function(t){a.stpP(t)})}function Yr(t,e,n){var r=t?wn:gn,i=t?ct:ft;e?J.removeClass(r):J.addClass(r),n?i.removeClass(Vn):i.addClass(Vn)}function Kr(t,e){if(clearTimeout(ue),t)ct.removeClass(Xn),ft.removeClass(Xn);else{var n="active",r=function(){if(!we){var t=ut.hasClass(n)||pt.hasClass(n);!t&&(de||ve||ye)&&ct.addClass(Xn),!t&&(de||ve||ye)&&ft.addClass(Xn)}};he>0&&!0!==e?ue=setTimeout(r,he):r()}}function $r(t){var e={},n=Zr(t),r=Math.min(1,(dt[n._wh]-(Tt?t?W:L:0))/vt[n._wh]);e[n.wh]=Math.floor(100*r*1e5)/1e5+"%",si()||n.h.css(e),n.i.hl=n.h[0]["offset"+n.WH],n.i.hlr=r}function Gr(t,e){var n,r,i=D&&t,o={},a=Zr(t),s="translate(",c="transform",l=rt[0][Ve+a.WH]-rt[0]["client"+a.WH],u=a.i.hl,f=a.t[0]["offset"+a.WH],h=f-u;v.n&&i&&(l*=-1),r=e/l,r=isNaN(r)?0:Math.min(1,r),a.i.ms=l,a.i.cs=e,a.i.csr=r,h*=r,h=isNaN(h)?0:h,i&&(v.n||!v.n&&!v.i)&&(h=f-u-h),h=Math.max(0,h),O?(i&&(h=-(f-u-h)),n=t?s+h+"px, 0px)":s+"0px, "+h+"px)",o["-webkit-"+c]=n,o["-moz-"+c]=n,o["-ms-"+c]=n,o["-o-"+c]=n,o[c]=n):o[a.lt]=h,si()||a.h.css(o),a.i.ho=h,a.i.tl=f}function Jr(t,e){var n=e?"removeClass":"addClass",r=t?ht:pt,i=t?_n:Qn;(t?lt:ut)[n](i),r[n](i)}function Zr(t){return{wh:t?Be:qe,WH:t?"Width":"Height",lt:t?je:Pe,LT:t?"Left":"Top",xy:t?Ye:Ke,XY:t?"X":"Y",_wh:t?"w":"h",_lt:t?"l":"t",t:t?lt:ht,h:t?ut:pt,s:t?ct:ft,i:t?Ae:ze}}function ti(t,e){z&&c.isFunction(t)&&t.call(Ce,e)}function ei(t,e,r){r===n&&(r=[Ue,Ue,Ue,Ue]),t[e+Pe]=r[0],t[e+Ne]=r[1],t[e+Re]=r[2],t[e+je]=r[3]}function ni(e){return typeof t.HTMLElement===i.o?e instanceof t.HTMLElement:e&&typeof e===i.o&&null!==e&&1===e.nodeType&&typeof e.nodeName===i.s}function ri(t,e){var n,r=[],i=[];for(n=0;nu&&(l=r+1,u=e);return{cursorRow:f,cursorCol:h,rows:s,cols:u,wRow:l,pos:t,max:o}}}function ai(t){for(var e=0;e"+(e||Ue)+""}function fi(t,e){for(var n,r=e.split($e),o=0;o9||!y?G.on("input",Sr):G.on(ln,Ar).on(un,zr)}else wi(G,yn),(J=G).wrapInner(ui(Wn)).wrapInner(ui(Hn)).wrapInner(ui(En)),ot=li(J,$e+Wn),rt=li(J,$e+Hn),nt=li(J,$e+En),ot.on(hn,function(t){!0!==Lt&&qr((t=t.originalEvent||t).propertyName)&&Ur(Qe)});if(Vr(),C?fr(rt,Ve,Or):rt.on(Ve,Or),w&&wi(rt,p.x&&p.y?In:kn),se){var s,l,f,h,M,k,I=a.mO(),W=a.now();ie=new I(function(t){if(z&&!F){var e,n=!1;c.each(t,function(){if(s=(e=this).target,l=e.attributeName,n=l===o.c?jr(e.oldValue,s.className):l!==o.s||e.oldValue!==s.style.cssText)return!1}),n&&Ce.update(Qe)}}),oe=new I(function(t){if(z&&!F){var e=!1;c.each(t,function(){return!(e=Dr(this))}),e&&(h=a.now(),M=xt||gt,k=function(){W=h,E&&_r(),M?Ce.update():Ce.update(Qe)},clearTimeout(f),ar<=0||h-W>ar||!M?k():f=setTimeout(k,ar))}})}return H&&(wi(K,vn),rt[en](n.l),rt[nn](n.t)),tt=c(ui("os-resize-observer-host")),J.prepend(tt),pr(tt,gr),gr(),Ce.update(Qe),setTimeout(function(){b&&!T&&wi(J,xn)},333),z=!0,ti(r.onInitialized),z}}return t[r]=function(e,i){if(0===arguments.length)return this;O();var o,a,f=[];return c.isPlainObject(i)?e&&e.length?(c.each(e,function(){o=this,console.log(o),o!==n&&f.push(A(o,i,l,u))}),a=f.length>1?f:f[0]):a=A(e,i,l,u):e&&(e.length&&e.length>0?(c.each(e,function(){o=s.get(this),"!"===i?o instanceof t[r]&&f.push(o):f.push(o)}),a=f.length>1?f:f[0]):a=s.get(e)),a},t[r].globals=function(){O();var t=c.extend(!0,{},l);return delete t.msie,t},t[r].defaultOptions=function(t){O();var e=l.defaultOptions;if(t===n)return c.extend(!0,{},e);l.defaultOptions=c.extend(!0,{},e,M.v(t,M.t,!0))},t[r]}(a,function(t){var e=[],r="__overlayScrollbars__";function i(t,n){t[r]=n,e.push(t)}function o(n){var i=t.inArray(n,e);i>-1&&(delete n[r],e.splice(i,1))}function a(t){return s(t)!==n}function s(t){for(var n=0;n -1) { - delete target[_instancePropertyString]; - _targets.splice(index, 1); - } - } - - /** - * Checks if the target element has a registered instance. - * @param target The target element. - * @returns {boolean} True if the target element is already registered, false otherwise. - */ - function targetHasRegisteredInstance(target) { - return getRegisteredInstanceFromTarget(target) !== undefined; - } - - /** - * Gets the registered instance of the given element. - * @param target The target element. - * @returns {*} The registered instance of the target or undefined if there isn't any. - */ - function getRegisteredInstanceFromTarget(target) { - for(var i = 0; i < _targets.length; i++) - if(target === _targets[i]) - return target[_instancePropertyString]; - - } - - return { - all : function() { - return _targets; - }, - add : registerInstanceToTarget, - rem : unregisterInstanceFromTarget, - has : targetHasRegisteredInstance, - get : getRegisteredInstanceFromTarget + var LEXICON = { + c : 'class', + s : 'style', + i : 'id', + oH : 'offsetHeight', + cH : 'clientHeight', + sH : 'scrollHeight', + oW : 'offsetWidth', + cW : 'clientWidth', + sW : 'scrollWidth' }; - })(HELPER); - var BYPROPERTYPATH = (function(helper) { - /** - * Super 1337 recursive method which i don't want to document entirely. - * @param object The object. - * @param propertyString The PropertyString. - * @param propertyStringProgress The PropertyStringProgress (generated automatically because of recursion, if you call this method manually, pass undefined or a empty string!) - * @param callbackOnProperty Callback which gets called if the property was found. - * @param callbackOnParentObject - * @returns {boolean|string} True if property found, false or string otherwise. A string indicates where the property path couldn't be resolved anymore. - */ - function _getPropertyByStringMaster(object, propertyString, propertyStringProgress, callbackOnProperty, callbackOnParentObject) { - var found = false; - - propertyStringProgress = propertyStringProgress === undefined ? '' : propertyStringProgress; - - if (typeof propertyString !== TYPES.s) - return found; - if (propertyString.length === 0) - return found; - - if (propertyStringProgress === '') { - var nameSplit = propertyString.split('.'); - var currObj = object; - var nameProgression = ''; - var pathIsInvalid = false; - - for (var i = 0; i < nameSplit.length; i++) { - var currSplit = nameSplit[i]; - currObj = currObj[currSplit]; - nameProgression += currSplit + '.'; - if (helper.type(currObj) !== TYPES.o && i + 1 !== nameSplit.length) { - pathIsInvalid = true; - break; - } - } - if (pathIsInvalid) - return nameProgression.slice(0, -1); - } - - for (var prop in object) { - if (object.hasOwnProperty(prop)) { - var isSearchedProperty = (propertyStringProgress + prop) === propertyString; - if (helper.type(object[prop]) === TYPES.o && !isSearchedProperty) { - found = _getPropertyByStringMaster(object[prop], propertyString, propertyStringProgress + prop + '.', callbackOnProperty, callbackOnParentObject); - if (typeof callbackOnParentObject === TYPES.f) - callbackOnParentObject(object, prop); - if (found) - break; - } - else if (isSearchedProperty) { - if (typeof callbackOnProperty === TYPES.f) - callbackOnProperty(object, prop); - found = true; - break; - } - } - } - - return found; - } - - return { + var COMPATIBILITY = { /** - * Indicates whether the given object has the given property path. - * @param object {object} The object to which the property path shall be applied. - * @param propertyPath {string} The property path which shall be checked. - * @returns {boolean} True if the object has the given property path, false otherwise. + * Gets the current window width. + * @returns {Number|number} The current window width in pixel. */ - has : function(object, propertyPath) { - return _getPropertyByStringMaster(object, propertyPath); + wW: function() { + return window.innerWidth || document.documentElement[LEXICON.cW] || document.body[LEXICON.cW]; }, /** - * Gets the value of the property which is represented by the property path. - * @param object {object} The object to which the property path shall be applied. - * @param propertyPath {string} The property path which leads to the property which shall be get. - * @returns {object|undefined} The property value of the property to which the given property path led. Undefined if the property path led to a non existent property. + * Gets the current window height. + * @returns {Number|number} The current window height in pixel. */ - get : function(object, propertyPath) { - var result; - _getPropertyByStringMaster(object, propertyPath, '', function (obj, prop) { - result = obj[prop]; - }); - return result; + wH: function() { + return window.innerHeight || document.documentElement[LEXICON.cH] || document.body[LEXICON.cH]; }, /** - * Changes the value of the property which is represented by the property path. - * If the property to which the property path leads does not exist, then nothing happens. - * @param object {object} The object to which the property path shall be applied. - * @param propertyPath {string} The property path which leads to the property which shall be set. - * @param propertyValue {object} The value of the property to which the property path leads. - * @param create {boolean} Indicates whether the property shall be created if it is not existent. With this parameter set to true the return value will be also always true. - * @returns {boolean} True if the property was found and the value was successfully changed, false otherwise. + * Gets the MutationObserver Object or undefined if not supported. + * @returns {MutationObserver|*|undefined} The MutationsObserver Object or undefined. */ - set : function setPropertyByString(object, propertyPath, propertyValue, create) { - var result = false; - _getPropertyByStringMaster(object, propertyPath, '', function (obj, prop) { - obj[prop] = propertyValue; - result = true; - }); - if (!result && create) { - var propertyPathSplits = propertyPath.split('.'); - var obj = {}; - var tmp = obj; - for (var i = 0; i < propertyPathSplits.length; i++) { - var value = i === propertyPathSplits.length - 1 ? propertyValue : { }; - tmp = tmp[propertyPathSplits[i]] = value; - } - helper.extend(true, object, obj); - result = true; - } - return result; + mO: function() { + return window.MutationObserver || window.WebKitMutationObserver || window.WebkitMutationObserver || window.MozMutationObserver || undefined; }, /** - * Deletes the property which is represented by the property path. - * @param object {object} The object to which the property path shall be applied. - * @param propertyPath {string} The property path which leads to the property which shall be deleted. - * @param deleteParentObjectIfEmpty {boolean} True if the parent object of the property which shall be deleted, shall be deleted too if it is empty after the deletion of the property. - * @returns {boolean} True if the property to which the property path shall lead, was found and deleted, false otherwise. + * Gets the ResizeObserver Object or undefined if not supported. + * @returns {MutationObserver|*|undefined} The ResizeObserver Object or undefined. */ - del : function delPropertyByString(object, propertyPath, deleteParentObjectIfEmpty) { - var result = false; - _getPropertyByStringMaster(object, propertyPath, '', function (obj, prop) { - delete obj[prop]; - result = true; - }, function (obj, prop) { - if (deleteParentObjectIfEmpty) { - if (helper.isEmptyObject(obj[prop])) { - delete obj[prop]; - } - } - }); - return result; - } - }; - })(HELPER); - var PLUGIN = (function(compatibility, instances, helper, byPropertyPath) { - var _pluginGlobals; - var _pluginAutoUpdateLoop; - var _pluginDefaultOptions = { - className : 'os-theme-dark', //null || string - resize : 'none', //none || both || horizontal || vertical || n || b || h || v - sizeAutoCapable : true, //true || false - clipAlways : true, //true || false - normalizeRTL : true, //true || false - paddingAbsolute : false, //true || false - autoUpdate : null, //true || false || null - autoUpdateInterval : 33, //number - nativeScrollbarsOverlaid : { - showNativeScrollbars : false, //true || false - initialize : true //true || false + rO: function() { + return window.ResizeObserver || window.WebKitResizeObserver || window.WebkitResizeObserver || window.MozResizeObserver || undefined; }, - overflowBehavior : { - x : 'scroll', //visible-hidden || visible-scroll || hidden || scroll || v-h || v-s || h || s - y : 'scroll' //visible-hidden || visible-scroll || hidden || scroll || v-h || v-s || h || s - }, - scrollbars : { - visibility : 'auto', //visible || hidden || auto || v || h || a - autoHide : 'never', //never || scroll || leave || move || n || s || l || m - autoHideDelay : 800, //number - dragScrolling : true, //true || false - clickScrolling : false, //true || false - touchSupport : true //true || false - }, - textarea : { - dynWidth : false, //true || false - dynHeight : false //true || false - }, - callbacks : { - onInitialized : null, //null || function - onInitializationWithdrawn : null, //null || function - onDestroyed : null, //null || function - onScrollStart : null, //null || function - onScroll : null, //null || function - onScrollStop: null, //null || function - onOverflowChanged : null, //null || function - onOverflowAmountChanged : null, //null || function - onDirectionChanged : null, //null || function - onContentSizeChanged : null, //null || function - onHostSizeChanged : null, //null || function - onUpdated : null //null || function - } - }; - /** - * Initializes the object which contains global information about the plugin and each instance of it. - */ - function initOverlayScrollbarsStatics() { - if(_pluginGlobals === undefined) - _pluginGlobals = new OverlayScrollbarsGlobals(_pluginDefaultOptions); - if(_pluginAutoUpdateLoop === undefined) - _pluginAutoUpdateLoop = new OverlayScrollbarsAutoUpdateLoop(_pluginGlobals); - } - - /** - * The global object for the hide scrollbars objects. It contains resources which every hide scrollbars object needs. This object is initialized only once: if the first hide scrollbars object gets initialized. - * @param defaultOptions - * @constructor - */ - function OverlayScrollbarsGlobals(defaultOptions) { - var _base = this; - _base.defaultOptions = defaultOptions; - _base.autoUpdateLoop = false; - _base.autoUpdateRecommended = compatibility.mO() === undefined; - var bodyElement = helper('body'); - var scrollbarDummyElement = helper('
'); - var nativeScrollbarSize = (function() { - bodyElement.append(scrollbarDummyElement); - var strOverflow = 'overflow'; - var strHidden = 'hidden'; - var scrollbarDummyElement0 = scrollbarDummyElement[0]; - var dummyContainerChild = helper(scrollbarDummyElement.children('div').first()); - var IEBUGFIX = scrollbarDummyElement0[WORDING.oH]; //IE9 causes a bug where offsetHeight is zero for no reason - var scrollbarSize; - if(IEBUGFIX === 0) - scrollbarDummyElement.hide().show(); - scrollbarSize = { - x: scrollbarDummyElement0[WORDING.oH] - scrollbarDummyElement0[WORDING.cH], - y: scrollbarDummyElement0[WORDING.oW] - scrollbarDummyElement0[WORDING.cW] - }; - //https://bugzilla.mozilla.org/show_bug.cgi?id=1439305 - _base.restrictedMeasuring = (function() { - scrollbarDummyElement.css(strOverflow, strHidden); - var scrollSize = { - w : scrollbarDummyElement0[WORDING.sW], - h : scrollbarDummyElement0[WORDING.sH] + /** + * Gets the RequestAnimationFrame method or it's corresponding polyfill. + * @returns {*|Function} The RequestAnimationFrame method or it's corresponding polyfill. + */ + rAF: function() { + return window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function (func) { + return window.setTimeout(func, 1000 / 60); }; - scrollbarDummyElement.css(strOverflow, 'visible'); - var scrollSize2 = { - w : scrollbarDummyElement0[WORDING.sW], - h : scrollbarDummyElement0[WORDING.sH] + }, + + /** + * Gets the CancelAnimationFrame method or it's corresponding polyfill. + * @returns {*|Function} The CancelAnimationFrame method or it's corresponding polyfill. + */ + cAF: function() { + return window.cancelAnimationFrame || window.webkitCancelAnimationFrame || window.mozCancelAnimationFrame || window.oCancelAnimationFrame || window.msCancelAnimationFrame || function (id) { + return window.clearTimeout(id); }; - return (scrollSize.w - scrollSize2.w) !== 0 || (scrollSize.h - scrollSize2.h) !== 0; - })(); - _base.nativeScrollbarStyling = (function() { - scrollbarDummyElement.addClass('os-viewport-native-scrollbars-invisible'); - scrollbarDummyElement.css(strOverflow, strHidden).hide().css(strOverflow, 'scroll').show(); //fix opera bug: scrollbar styles will only appear if overflow value is scroll or auto during the activation of the style. - return (scrollbarDummyElement0[WORDING.oH] - scrollbarDummyElement0[WORDING.cH]) === 0 && (scrollbarDummyElement0[WORDING.oW] - scrollbarDummyElement0[WORDING.cW]) === 0; - })(); - _base.rtlScrollBehavior = (function() { - scrollbarDummyElement.css({ 'overflow-y' : strHidden, 'direction' : 'rtl' }).scrollLeft(0); - var dummyContainerOffset = scrollbarDummyElement.offset(); - var dummyContainerChildOffset = dummyContainerChild.offset(); - scrollbarDummyElement.scrollLeft(999); - var dummyContainerScrollOffsetAfterScroll = dummyContainerChild.offset(); + }, + + /** + * Gets the current time. + * @returns {number} The current time. + */ + now: function() { + return Date.now() || new Date().getTime(); + }, + + /** + * Stops the propagation of the given event. + * @param e The event of which the propagation shall be stoped. + */ + stpP: function(e) { + if(e.stopPropagation) + e.stopPropagation(); + else + e.cancelBubble = true; + }, + + /** + * Prevents the default action of the given event. + * @param e The event of which the default action shall be prevented. + */ + prvD: function(e) { + if(e.preventDefault) + e.preventDefault(); + else + e.returnValue = false; + }, + + /** + * Gets the pageX and pageY values of the given mouse event. + * @param e The mouse event of which the pageX and pageX shall be got. + * @returns {x: number, y: number} x = pageX value, y = pageY value. + */ + page: function(e) { + e = e.originalEvent || e; + + var strPage = 'page'; + var strClient = 'client'; + var strX = 'X'; + var strY = 'Y'; + var target = e.target || e.srcElement || document; + var eventDoc = target.ownerDocument || document; + var doc = eventDoc.documentElement; + var body = eventDoc.body; + + //if touch event return return pageX/Y of it + if(e.touches !== undefined) { + var touch = e.touches[0]; 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 - }; - })(); - scrollbarDummyElement.removeAttr(WORDING.s).remove(); - return scrollbarSize; - })(); - var nativeScrollbarIsOverlaid = { - x: nativeScrollbarSize.x === 0, - y: nativeScrollbarSize.y === 0 - }; - _base.nativeScrollbarSize = nativeScrollbarSize; - _base.nativeScrollbarIsOverlaid = nativeScrollbarIsOverlaid; - _base.overlayScrollbarDummySize = { - x: 30, - y: 30 - }; - _base.msie = (function() { - var ua = window.navigator.userAgent; - - var msie = ua.indexOf('MSIE '); - if (msie > 0) { - // IE 10 or older => return version number - return parseInt(ua.substring(msie + 5, ua.indexOf('.', msie)), 10); - } - - var trident = ua.indexOf('Trident/'); - if (trident > 0) { - // IE 11 => return version number - var rv = ua.indexOf('rv:'); - return parseInt(ua.substring(rv + 3, ua.indexOf('.', rv)), 10); - } - - var edge = ua.indexOf('Edge/'); - if (edge > 0) { - // Edge (IE 12+) => return version number - return parseInt(ua.substring(edge + 5, ua.indexOf('.', edge)), 10); - } - - // other browser - return false; - })(); - _base.cssCalc = (function() { - var dummy = document.createElement('div'); - var props = ['calc', '-webkit-calc', '-moz-calc', '-o-calc']; - for (var i = 0; i < props.length; ++i) { - var prop = props[i]; - dummy.style.cssText = 'width:' + prop + '(1px);'; - if (dummy.style.length) - return prop; - } - return null; - })(); - function detectCSSFeature(featurename) { - var feature = false, - domPrefixes = 'Webkit Moz ms O'.split(' '), - elm = document.createElement('div'), - featurenameCapital = null; - - featurename = featurename.toLowerCase(); - - if (elm.style[featurename] !== undefined) { - feature = true; - } - - if (feature === false) { - featurenameCapital = featurename.charAt(0).toUpperCase() + featurename.substr(1); - for (var i = 0; i < domPrefixes.length; i++) { - if (elm.style[domPrefixes[i] + featurenameCapital] !== undefined) { - feature = true; - break; - } + x : touch[strPage + strX], + y : touch[strPage + strY] } } - return feature; - } - _base.supportTransform = detectCSSFeature("transform"); - _base.supportTransition = detectCSSFeature("transition"); - //passive event support - var supportsPassive = false; - try { - var opts = Object.defineProperty({}, 'passive', { - get: function() { - supportsPassive = true; - } - }); - window.addEventListener('test', null, opts); - } catch (e) { } - _base.supportPassiveEvents = supportsPassive; - _base.supportResizeObserver = compatibility.rO() !== undefined; - _base.supportMutationObserver = compatibility.mO() !== undefined; - //Catch zoom event: - (function () { - if(nativeScrollbarIsOverlaid.x && nativeScrollbarIsOverlaid.y) - return; + // Calculate pageX/Y if not native supported + if (!e[strPage + strX] && e[strClient + strX] && e[strClient + strX] != null) { - var windowWidth = compatibility.wW(); - var windowHeight = compatibility.wH(); - var windowDpr = getWindowDPR(); - - function differenceIsBiggerThanOne(valOne, valTwo) { - var absValOne = Math.abs(valOne); - var absValTwo = Math.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); - } - - helper(window).on('resize', function() { - if(instances.all().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 = Math.abs(deltaW); - var absDeltaH = Math.abs(deltaH); - var absDeltaWRatio = Math.abs(deltaWRatio); - var absDeltaHRatio = Math.abs(deltaHRatio); - var newDPR = getWindowDPR(); - - var deltaIsBigger = absDeltaW > 2 && absDeltaH > 2; - var difference = !differenceIsBiggerThanOne(absDeltaWRatio, absDeltaHRatio); - var dprChanged = newDPR !== windowDpr && windowDpr > 0; - var windowResized = !(deltaIsBigger && difference && dprChanged); - - if (!windowResized) { - bodyElement.append(scrollbarDummyElement); - var measure = scrollbarDummyElement[0]; - _base.nativeScrollbarSize = { - x: measure[WORDING.oH] - measure[WORDING.cH], - y: measure[WORDING.oW] - measure[WORDING.cW] - }; - scrollbarDummyElement.remove(); - helper.each(instances.all(), function () { - if(instances.has(this)) - instances.get(this).update('zoom'); - }); - } - - windowWidth = newW; - windowHeight = newH; - windowDpr = newDPR; - } - }); - })(); - } - - /** - * The object which manages the auto update loop for all hide scrollbars objects. This object is initialized only once: if the first hide scrollbars object gets initialized. - * @constructor - */ - function OverlayScrollbarsAutoUpdateLoop(globals) { - var _base = this; - var _strAutoUpdate = 'autoUpdate'; - var _strAutoUpdateInterval = _strAutoUpdate + 'Interval'; - - 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.length > 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.length; 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(helper.inArray(instance, _loopingInstances) === -1) { - _loopingInstances.push(instance); - _loopingInstancesIntervalCache.push(compatibility.now()); - if (_loopingInstances.length > 0 && !_loopIsActive) { - _loopIsActive = true; - globals.autoUpdateLoop = _loopIsActive; - loop(); + return { + x : e[strClient + strX] + + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - + (doc && doc.clientLeft || body && body.clientLeft || 0), + y : e[strClient + strY] + + (doc && doc.scrollTop || body && body.scrollTop || 0) - + (doc && doc.clientTop || body && body.clientTop || 0) } } - }; - - /** - * 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 = helper.inArray(instance, _loopingInstances); - if(index > -1) { - //remove from loopingInstances list - _loopingInstancesIntervalCache.splice(index, 1); - _loopingInstances.splice(index, 1); - - //correct update loop behavior - if (_loopingInstances.length === 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 globals - * @param autoUpdateLoop - * @returns {*} - * @constructor - */ - function OverlayScrollbarsInstance(pluginTargetElement, options, 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.has(pluginTargetElement)) { - var inst = instances.get(pluginTargetElement); - inst.options(options); - return inst; - } - - //make correct instanceof - var _base = new window[PLUGINNAME](); - - //general: - var _initialized = false; - var _destroyed = false; - var _isTextarea = false; - var _isBody = false; - var _sizeAutoObserverAdded = false; - var _contentBorderSize = { w: 0, h: 0 }; - var _scrollHorizontalInfo = { }; - var _scrollVerticalInfo = { }; - var _viewportSize = { }; - var _rtlScrollBehavior; - var _autoUpdateRecommended; - var _msieVersion; - var _nativeScrollbarStyling; - var _cssCalc; - var _nativeScrollbarSize; - var _nativeScrollbarMinSize; - var _nativeScrollbarIsOverlaid; - var _overlayScrollbarDummySize; - var _supportTransition; - var _supportTransform; - var _supportPassiveEvents; - var _supportResizeObserver; - var _restrictedMeasuring; - var _isBorderBox; - var _paddingX; - var _paddingY; - var _borderX; - var _borderY; - var _marginX; - var _marginY; - var _isRTL; - var _isSleeping; - - //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 _strDivBegin = "
"; - 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'; - 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; - - //update - var _lastUpdateTime; - var _swallowedUpdateParams = { }; - var _swallowedUpdateTimeout; - var _swallowUpdateLag = 33; - var _imgs = [ ]; - - //DOM elements: - var _windowElement; - var _documentElement; - var _htmlElement; - var _bodyElement; - var _targetElement; //the target element of this hide scrollbars object - var _hostElement; //the host element of this hide scrollbars 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; - - //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 = { - x: 0, - y: 0 - }; - var _resizeDragStartSize = { - w: 0, - h: 0 - }; - - /** - * 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 onHostResized() { - if (_isSleeping) - return; - var measureElement = _sizeObserverElement[0]; - var hostSize = { - w: measureElement[WORDING.sW], - h: measureElement[WORDING.sH] + return { + x : e[strPage + strX], + y : e[strPage + strY] }; - if (_initialized) { - var changed = checkCacheDouble(hostSize, _hostElementSizeChangeDetectedCache); - _hostElementSizeChangeDetectedCache = hostSize; - if (changed) - update(true, false); + }, + + /** + * Gets the clicked mouse button of the given mouse event. + * @param e The mouse event of which the clicked button shal be got. + * @returns {number} The number of the clicked mouse button. (1 : leftButton | 2 : middleButton | 3 : rightButton) + */ + mBtn: function(e) { + if (!e.which && e.button !== undefined) + return (e.button & 1 ? 1 : (e.button & 2 ? 3 : (e.button & 4 ? 2 : 0))); + else + return e.which; + }, + + bind: function(func, oThis) { + if (typeof func !== TYPES.f) { + throw "Can't bind function!"; + // closest thing possible to the ECMAScript 5 + // internal IsCallable function + //throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable'); } - else { - _hostElementSizeChangeDetectedCache = hostSize; + + var aArgs = Array.prototype.slice.call(arguments, 2); + var fNOP = function() {}; + var fBound = function() { return func.apply(this instanceof fNOP ? this : oThis, aArgs.concat(Array.prototype.slice.call(arguments))); }; + + if (func.prototype) + fNOP.prototype = func.prototype; // Function.prototype doesn't have a prototype property + fBound.prototype = new fNOP(); + + return fBound; + } + }; + + var FRAMEWORK = framework; + var INSTANCES = (function(helper) { + var _targets = [ ]; + var _instancePropertyString = '__overlayScrollbars__'; + + /** + * Registers the given instance to the given element. + * @param target The target element. + * @param instance The instance. + */ + function registerInstanceToTarget(target, instance) { + target[_instancePropertyString] = instance; + _targets.push(target); + } + + /** + * Unregisters the instance from the given element. + * @param target The target element. + */ + function unregisterInstanceFromTarget(target) { + var index = helper.inArray(target, _targets); + if (index > -1) { + delete target[_instancePropertyString]; + _targets.splice(index, 1); } } /** - * 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. + * Checks if the target element has a registered instance. + * @param target The target element. + * @returns {boolean} True if the target element is already registered, false otherwise. */ - 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}); + function targetHasRegisteredInstance(target) { + return getRegisteredInstanceFromTarget(target) !== undefined; } /** - * 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. + * Gets the registered instance of the given element. + * @param target The target element. + * @returns {*} The registered instance of the target or undefined if there isn't any. */ - function removePassiveEventListener(element, eventNames, listener) { - var events = eventNames.split(_strSpace); - for (var i = 0; i < events.length; i++) - element[0].removeEventListener(events[i], listener); + function getRegisteredInstanceFromTarget(target) { + for(var i = 0; i < _targets.length; i++) + if(target === _targets[i]) + return target[_instancePropertyString]; + } - /** - * 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); + return { + all : function() { + return _targets; + }, + add : registerInstanceToTarget, + rem : unregisterInstanceFromTarget, + has : targetHasRegisteredInstance, + get : getRegisteredInstanceFromTarget + }; + })(FRAMEWORK); + var PLUGIN = (function(compatibility, instances, helper) { + var _pluginsGlobals; + var _pluginsAutoUpdateLoop; + var _pluginsOptions = (function() { + var possibleTemplateTypes = [ + TYPES.b, //boolean + TYPES.n, //number + TYPES.s, //string + TYPES.a, //array + TYPES.o, //object + TYPES.f, //function + TYPES.z //null + ]; + var restrictedStringsSplit = " "; + var restrictedStringsPossibilitiesSplit = ":"; + var classNameAllowedValues = [TYPES.z, TYPES.s]; + var booleanAllowedValues = TYPES.b; + var numberAllowedValues = TYPES.n; + var booleanNullAllowedValues = [TYPES.z, booleanAllowedValues]; + var callbackAllowedValues = [TYPES.z, TYPES.f]; + var resizeAllowedValues = 'n:none b:both h:horizontal v:vertical'; + var overflowBehaviorAllowedValues = 'v-h:visible-hidden v-s:visible-scroll s:scroll h:hidden'; + var scrollbarsVisibilityAllowedValues = 'v:visible h:hidden a:auto'; + var scrollbarsAutoHideAllowedValues = 'n:never s:scroll l:leave m:move'; + var optionsDefaultsAndTemplate = { + className: ['os-theme-dark', classNameAllowedValues], //null || string + resize: ['none', resizeAllowedValues], //none || both || horizontal || vertical || n || b || h || v + sizeAutoCapable: [true, booleanAllowedValues], //true || false + clipAlways: [true, booleanAllowedValues], //true || false + normalizeRTL: [true, booleanAllowedValues], //true || false + paddingAbsolute: [false, booleanAllowedValues], //true || false + autoUpdate: [null, booleanNullAllowedValues], //true || false || null + autoUpdateInterval: [33, numberAllowedValues], //number + nativeScrollbarsOverlaid: { + showNativeScrollbars: [false, booleanAllowedValues], //true || false + initialize: [true, booleanAllowedValues] //true || false + }, + overflowBehavior: { + x: ['scroll', overflowBehaviorAllowedValues], //visible-hidden || visible-scroll || hidden || scroll || v-h || v-s || h || s + y: ['scroll', overflowBehaviorAllowedValues] //visible-hidden || visible-scroll || hidden || scroll || v-h || v-s || h || s + }, + scrollbars: { + visibility: ['auto', scrollbarsVisibilityAllowedValues], //visible || hidden || auto || v || h || a + autoHide: ['never', scrollbarsAutoHideAllowedValues], //never || scroll || leave || move || n || s || l || m + autoHideDelay: [800, numberAllowedValues], //number + dragScrolling: [true, booleanAllowedValues], //true || false + clickScrolling: [false, booleanAllowedValues], //true || false + touchSupport: [true, booleanAllowedValues] //true || false + }, + textarea: { + dynWidth: [false, booleanAllowedValues], //true || false + dynHeight: [false, booleanAllowedValues] //true || false + }, + callbacks: { + onInitialized: [null, callbackAllowedValues], //null || function + onInitializationWithdrawn: [null, callbackAllowedValues], //null || function + onDestroyed: [null, callbackAllowedValues], //null || function + onScrollStart: [null, callbackAllowedValues], //null || function + onScroll: [null, callbackAllowedValues], //null || function + onScrollStop: [null, callbackAllowedValues], //null || function + onOverflowChanged: [null, callbackAllowedValues], //null || function + onOverflowAmountChanged: [null, callbackAllowedValues], //null || function + onDirectionChanged: [null, callbackAllowedValues], //null || function + onContentSizeChanged: [null, callbackAllowedValues], //null || function + onHostSizeChanged: [null, callbackAllowedValues], //null || function + onUpdated: [null, callbackAllowedValues] //null || function } - /* - else { - targetElement = targetElement.children(_strDot + _classNameResizeObserverElement).first(); - var w = targetElement.css(_strWidth); - var h = targetElement.css(_strHeight); - var css = {}; - css[_strWidth] = w; - css[_strHeight] = h; - targetElement.css(css); - } + //extensions : [{ }, TYPES.o] + }; + var convert = function(template) { + var recursive = function(obj) { + var key; + var val; + var valType; + for(key in obj) { + if(!obj.hasOwnProperty(key)) + continue; + val = obj[key]; + valType = helper.type(val); + if(valType === TYPES.a) + obj[key] = val[template ? 1 : 0]; + else if(valType === TYPES.o) + obj[key] = recursive(val); + } + return obj; + }; + return recursive(helper.extend(true, { }, optionsDefaultsAndTemplate)); + }; + + return { + //defaults + d : convert(), + + //template + t : convert(true), + + //validate + /** + * Validates the passed object by the passed template. + * @param obj The object which shall be validated. + * @param template The template which defines the allowed values and types. + * @param writeErrors True if errors shall be logged to the console. + * @param usePreparedValues True if the validated main values shall be returned in the validated object, false otherwise. + * @param keepForeignProps True if properties which aren't in the template shall be added to the validated object, false otherwise. + * @returns {{}} A object which contains only the valid properties of the passed original object. */ - } - } - - /** - * 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).first().css(css); - } - */ - } - } - - /** - * 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 callback = function (e) { - targetElement.scrollTop(constMaximum); - targetElement.scrollLeft(_isRTL ? _rtlScrollBehavior.n ? -constMaximum : _rtlScrollBehavior.i ? 0 : constMaximum : constMaximum); - onElementResizedCallback(); - }; - if (_supportResizeObserver) { - var resizeObserver = compatibility.rO(); - var element = targetElement.append(_strDivBegin + _classNameResizeObserverElement + ' observed' + _strDivEnd).contents()[0]; - var observer = element[_strResizeObserverProperty] = new resizeObserver(callback); - observer.observe(element); - } - else { - var strAnimationStartEvent = 'animationstart mozAnimationStart webkitAnimationStart MSAnimationStart'; - if (_msieVersion > 9 || !_autoUpdateRecommended) { - var strDivClose = '">'; - var strDivEnd = ""; - var strChildNodes = 'childNodes'; - var observerDOM = _strDivBegin + _classNameResizeObserverElement + strDivClose; - observerDOM += _strDivBegin + _classNameResizeObserverItemElement + '" dir="ltr' + strDivClose; - observerDOM += _strDivBegin + _classNameResizeObserverItemElement + strDivClose; - observerDOM += _strDivBegin + _classNameResizeObserverItemFinalElement + _strDivEnd; - observerDOM += strDivEnd; - observerDOM += _strDivBegin + _classNameResizeObserverItemElement + strDivClose; - observerDOM += _strDivBegin + _classNameResizeObserverItemFinalElement + '" style="width: 200%; height: 200%' + _strDivEnd; - observerDOM += strDivEnd; - observerDOM += strDivEnd; - observerDOM += strDivEnd; - - targetElement.prepend(observerDOM); - targetElement = targetElement[0]; - var observerElement = targetElement[strChildNodes][0][strChildNodes][0]; - var shrinkElement = helper(observerElement[strChildNodes][1]); - var expandElement = helper(observerElement[strChildNodes][0]); - var expandElementChild = helper(expandElement[0][strChildNodes][0]); - var widthCache = observerElement[WORDING.oW]; - var heightCache = observerElement[WORDING.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[WORDING.oW] + nativeScrollbarSize.x * factor + nativeScrollbarSize.y * factor + _overlayScrollbarDummySize.x + _overlayScrollbarDummySize.y; - var sizeResetHeight = observerElement[WORDING.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[WORDING.oW]; - currHeight = observerElement[WORDING.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 observerElementCSS = {}; - observerElementCSS[_strTop] = (-((nativeScrollbarSize.y + 1) * factor)); - observerElementCSS[_strRight] = (nativeScrollbarSize.x * -factor); - observerElementCSS[_strBottom] = (nativeScrollbarSize.y * -factor); - observerElementCSS[_strLeft] = (-((nativeScrollbarSize.x + 1) * factor)); - - helper(observerElement).css(observerElementCSS); - expandElement.on(_strScroll, onScroll); - shrinkElement.on(_strScroll, onScroll); - helper(targetElement).on(strAnimationStartEvent, function () { - onScroll(false); - }); - //lets assume that the divs will never be that large and a constant value is enough - var expandChildCSS = {}; - expandChildCSS[_strWidth] = constMaximum; - expandChildCSS[_strHeight] = constMaximum; - expandElementChild.css(expandChildCSS); - - reset(); - } - else { - var doc = _documentElement[0]; - var JQelement = targetElement; - targetElement = targetElement[0]; - var attachEvent = doc.attachEvent; - var isIE = typeof navigator !== TYPES.u ? navigator.userAgent.match(/Trident/) || navigator.userAgent.match(/Edge/) : true; - if (attachEvent) { - JQelement.prepend(_strDivBegin + _classNameResizeObserverElement + _strDivEnd); - JQelement.find(_strDot + _classNameResizeObserverElement).first()[0].attachEvent('onresize', callback); - } - else { - var obj = doc.createElement(TYPES.o); - obj.setAttribute('tabindex', '-1'); - obj.setAttribute(WORDING.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) - JQelement.prepend(obj); - obj.data = 'about:blank'; - if (!isIE) - JQelement.prepend(obj); - JQelement.on(strAnimationStartEvent, callback); - } - } - } - - //direction change detection: - targetElement = helper(targetElement); - if (targetElement[0] === _sizeObserverElement[0]) { - var directionChanged = function () { - var dir = _hostElement.css('direction'); - if (dir !== _cssDirectionDetectedCache) { - var css = {}; - var scrollLeftValue = 0; - 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().first().css(css); - targetElement.scrollLeft(scrollLeftValue); - targetElement.scrollTop(constMaximum); - _cssDirectionDetectedCache = dir; - return true; - } - return false; - }; - 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 { - targetElement.children(_strDot + _classNameResizeObserverElement).first().remove(); - } - } - - /** - * 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; - } - - /** - * Calls the given callback with the given args. The Context of this callback is always _base (this). - * @param callback The callback function which shall be called. - * @param args The args with which the callback shall be called. - */ - function callCallback(callback, args) { - if(_initialized) - callback.call(_base, 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]; - } - - /** - * Connects the MutationObservers if they are supported. - */ - function mutationObserversConnect() { - if (_supportMutationObserver && !_mutationObserverConnected) { - _mutationObserverHost.observe(_hostElement[0], { - attributes: true, - attributeOldValue: true, - attributeFilter: [WORDING.i, WORDING.c, WORDING.s] - }); - - _mutationObserverContent.observe(_isTextarea ? _targetElement[0] : _contentElement[0], { - attributes: true, - attributeOldValue: true, - subtree: !_isTextarea, - childList: !_isTextarea, - characterData: !_isTextarea, - attributeFilter: _isTextarea ? ['wrap', 'cols', 'rows'] : [WORDING.i, WORDING.c, WORDING.s] - }); - - _mutationObserverConnected = true; - } - } - - /** - * Disconnects the MutationObservers if they are supported. - */ - function mutationObserversDisconnect() { - if (_supportMutationObserver && _mutationObserverConnected) { - _mutationObserverHost.disconnect(); - _mutationObserverContent.disconnect(); - - _mutationObserverConnected = 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][WORDING.oW] - (!_isBorderBox ? _paddingX : 0); - _resizeDragStartSize.h = _hostElement[0][WORDING.oH] - (!_isBorderBox ? _paddingY : 0); - - _documentElement.on(_strSelectStartEvent, onSelectStart) - .on(_strMouseTouchMoveEvent, scrollbarCornerOnResize) - .on(_strMouseTouchUpEvent, scrollbarCornerOnResized); - - _bodyElement.addClass(_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 originalEvent = event.originalEvent || 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, onSelectStart) - .off(_strMouseTouchMoveEvent, scrollbarCornerOnResize) - .off(_strMouseTouchUpEvent, scrollbarCornerOnResized); - - _bodyElement.removeClass(_classNameDragging); - if (_scrollbarCornerElement.releaseCapture) - _scrollbarCornerElement.releaseCapture(); - - if (eventIsTrusted) { - if (_resizeReconnectMutationObserver) - mutationObserversConnect(); - _base.update(_strAuto); - } - _resizeReconnectMutationObserver = false; - } - - /** - * 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]; - - //reset min size - css[_strMinMinus + _strWidth] = _strEmpty; - css[_strMinMinus + _strHeight] = _strEmpty; - - //set width auto - css[_strWidth] = _strAuto; - _targetElement.css(css); - - //measure width - var origWidth = measureElement[WORDING.oW]; - var width = doMeasure ? Math.max(origWidth, measureElement[WORDING.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 - var origHeight = measureElement[WORDING.oH]; - var height = Math.max(origHeight, measureElement[WORDING.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 - }; - } - - /** - * 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.prop('selectionStart'); - if (textareaCursorPosition === undefined) - return; - var textareaValue = _targetElement.val(); - var textareaLength = textareaValue.length; - var textareaRowSplit = textareaValue.split("\n"); - var textareaLastRow = textareaRowSplit.length; - var textareaCurrentCursorRowSplit = textareaValue.substr(0, textareaCursorPosition).split("\n"); - var widestRow = 0; - var textareaLastCol = 0; - var cursorRow = textareaCurrentCursorRowSplit.length; - var cursorCol = textareaCurrentCursorRowSplit[textareaCurrentCursorRowSplit.length - 1].length; - - //get widest Row and the last column of the textarea - for (var i = 0; i < textareaRowSplit.length; i++) { - var rowCols = textareaRowSplit[i].length; - if (rowCols > textareaLastCol) { - widestRow = i + 1; - textareaLastCol = rowCols; - } - } - - return { - cursorRow: cursorRow, - cursorCol: cursorCol, - rows: textareaLastRow, - cols: textareaLastCol, - wRow: widestRow, - pos: textareaCursorPosition, - max: textareaLength - }; - } - - /** - * 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; - } - - /** - * 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 (helper.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 = helper.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 () { - 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; - } - - /** - * 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 onSelectStart(event) { - compatibility.prvD(event); - return false; - } - - /** - * A callback which will be called after a img element has downloaded its src asynchronous. - */ - function onImgLoad() { - update(); - } - - /** - * 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)); - } - - /** - * 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) - _hostElement.removeClass(scrollbarClassName); - else - _hostElement.addClass(scrollbarClassName); - - if (canScroll) - scrollbarElement.removeClass(_classNameScrollbarUnusable); - else - scrollbarElement.addClass(_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) - _scrollbarHorizontalElement.removeClass(_classNameScrollbarAutoHidden); - //if(_hasOverflowCache.y && _hideOverflowCache.ys) - _scrollbarVerticalElement.removeClass(_classNameScrollbarAutoHidden); - } - else { - var strActive = 'active'; - var hide = function () { - if (!_scrollbarsAutoHideFlagScrollAndHovered) { - var anyActive = _scrollbarHorizontalHandleElement.hasClass(strActive) || _scrollbarVerticalHandleElement.hasClass(strActive); - if (!anyActive && (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove || _scrollbarsAutoHideLeave)) - _scrollbarHorizontalElement.addClass(_classNameScrollbarAutoHidden); - if (!anyActive && (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove || _scrollbarsAutoHideLeave)) - _scrollbarVerticalElement.addClass(_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); - - //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 * 100000) / 100000) + "%"; //the last * 100000 / 100000 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); - - //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]; - - //if rtl scroll max is negative - if (_rtlScrollBehavior.n && isRTLisHorizontal) - maxScroll *= -1; - - var 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 - - var handleLength = scrollbarVars.i.hl; - var trackLength = scrollbarVars.t[0]['offset' + scrollbarVars.WH]; - var handleTrackDiff = trackLength - handleLength; - var offset = handleTrackDiff * posRatio; - offset = isNaN(offset) ? 0 : offset; - if (isRTLisHorizontal && (_rtlScrollBehavior.n || !_rtlScrollBehavior.n && !_rtlScrollBehavior.i)) - offset = trackLength - handleLength - offset; - offset = Math.max(0, offset); - - if (_supportTransform) { - if (isRTLisHorizontal) - offset = -(trackLength - handleLength - offset); - var translateValue; - var strTranslateBrace = 'translate('; - var strTransform = 'transform'; - if (isHorizontal) - translateValue = strTranslateBrace + offset + 'px, 0px)'; - else - translateValue = strTranslateBrace + '0px, ' + offset + '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); - } - - /** - * Builds all scrollbars if they aren't already build. - */ - function buildScrollbars() { - _scrollbarHorizontalElement = helper(_strDivBegin + _classNameScrollbar + _strSpace + _classNameScrollbarHorizontal + _strDivEnd); - _scrollbarHorizontalTrackElement = helper(_strDivBegin + _classNameScrollbarTrack + _strDivEnd); - _scrollbarHorizontalHandleElement = helper(_strDivBegin + _classNameScrollbarHandle + _strDivEnd); - _scrollbarVerticalElement = helper(_strDivBegin + _classNameScrollbar + _strSpace + _classNameScrollbarVertical + _strDivEnd); - _scrollbarVerticalTrackElement = helper(_strDivBegin + _classNameScrollbarTrack + _strDivEnd); - _scrollbarVerticalHandleElement = helper(_strDivBegin + _classNameScrollbarHandle + _strDivEnd); - - _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 = helper(_strDivBegin + _strSpace + _classNameScrollbarCorner + _strDivEnd); - _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 mouseDownScroll; - var mouseDownOffset; - var xy = scrollbarVars.xy; - var scroll = _strScroll + scrollbarVars.LT; - var strActive = 'active'; - var trackTimeout; - var scrollDurationFactor = 1; - var increaseTrackScrollAmount = function () { - scrollDurationFactor = 0.5; - }; - var decreaseTrackScrollAmount = function () { - scrollDurationFactor = 1; - }; - var handleDragMove = function (event) { - var originalEvent = event.originalEvent || event; - var trackLength = scrollbarVars.i.tl; - var handleLength = scrollbarVars.i.hl; - var scrollRange = scrollbarVars.i.ms; - var scrollRaw = (handleLength / 2) + compatibility.page(event)[xy] - mouseDownOffset; - var scrollDeltaPercent = (scrollRaw - (handleLength / 2)) / (trackLength - handleLength); - var scrollDelta = (scrollRange * scrollDeltaPercent); - scrollDelta = isFinite(scrollDelta) ? scrollDelta : 0; - if (_isRTL && isHorizontal && (_rtlScrollBehavior.n || !_rtlScrollBehavior.n && !_rtlScrollBehavior.i)) - scrollDelta *= -1; - _viewportElement[scroll](mouseDownScroll + scrollDelta); - - if (!_supportPassiveEvents) - compatibility.prvD(event); - }; - var documentMouseTouchUp = function (event) { - event = event || event.originalEvent; - _bodyElement.removeClass(_classNameDragging); - scrollbarVars.h.removeClass(strActive); - scrollbarVars.t.removeClass(strActive); - scrollbarVars.s.removeClass(strActive); - - if (_supportPassiveEvents) { - removePassiveEventListener(_documentElement, _strMouseTouchMoveEvent, handleDragMove); - removePassiveEventListener(_documentElement, _strMouseTouchUpEvent, documentMouseTouchUp); - removePassiveEventListener(_documentElement, _strKeyDownEvent, documentKeyDown); - removePassiveEventListener(_documentElement, _strKeyUpEvent, documentKeyUp); - } - else { - _documentElement.off(_strMouseTouchMoveEvent, handleDragMove) - .off(_strMouseTouchUpEvent, documentMouseTouchUp) - .off(_strKeyDownEvent, documentKeyDown) - .off(_strKeyUpEvent, documentKeyUp); - } - _documentElement.off(_strSelectStartEvent, onSelectStart); - - decreaseTrackScrollAmount(); - mouseDownScroll = undefined; - mouseDownOffset = undefined; - if (trackTimeout !== undefined) { - _base.scrollStop(); - clearTimeout(trackTimeout); - trackTimeout = undefined; - } - - //if mouse is outside host element - var rect = _hostElement[0].getBoundingClientRect(); - if (!(event.clientX >= rect.left && event.clientX <= rect.right && - event.clientY >= rect.top && event.clientY <= rect.bottom)) { - hostOnMouseLeave(); - } - if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) - refreshScrollbarsAutoHide(false); - }; - var documentKeyDown = function (event) { - if (event.keyCode == 16) - increaseTrackScrollAmount(); - }; - var documentKeyUp = function (event) { - if (event.keyCode == 16) - decreaseTrackScrollAmount(); - }; - scrollbarVars.h.on(_strMouseTouchDownEvent, function (event) { - if (_isSleeping) - return; - - var originalEvent = event.originalEvent || event; - var isTouchEvent = originalEvent.touches !== undefined; - if (nativeOverlayScrollbarsAreActive() || !_scrollbarsDragScrollingCache || (isTouchEvent && !_scrollbarsTouchSupport)) - return; - - if (compatibility.mBtn(event) === 1 || isTouchEvent) { - mouseDownScroll = _viewportElement[scroll](); - mouseDownScroll = mouseDownScroll === undefined ? 0 : mouseDownScroll; - if (_isRTL && isHorizontal && !_rtlScrollBehavior.n || !_isRTL) - mouseDownScroll = mouseDownScroll < 0 ? 0 : mouseDownScroll; - mouseDownOffset = compatibility.page(event)[xy]; - - _bodyElement.addClass(_classNameDragging); - scrollbarVars.h.addClass(strActive); - scrollbarVars.s.addClass(strActive); - - if (_supportPassiveEvents) { - addPassiveEventListener(_documentElement, _strMouseTouchMoveEvent, handleDragMove); - addPassiveEventListener(_documentElement, _strMouseTouchUpEvent, documentMouseTouchUp); - } - else { - _documentElement.on(_strMouseTouchMoveEvent, handleDragMove) - .on(_strMouseTouchUpEvent, documentMouseTouchUp); - } - _documentElement.on(_strSelectStartEvent, onSelectStart); - compatibility.prvD(event); - } - }); - scrollbarVars.t.on(_strMouseTouchDownEvent, function (event) { - if (_isSleeping) - return; - - var originalEvent = event.originalEvent || event; - var isTouchEvent = originalEvent.touches !== undefined; - if (nativeOverlayScrollbarsAreActive() || !_scrollbarsClickScrollingCache || (isTouchEvent && !_scrollbarsTouchSupport)) - return; - - if (compatibility.mBtn(event) === 1 || isTouchEvent) { - var scrollDistance = _viewportSize[scrollbarVars._wh]; - var trackOffset = scrollbarVars.t.offset()[scrollbarVars.lt]; - var decreaseScroll; - var isFirstIteration = true; - if (event.shiftKey) - increaseTrackScrollAmount(); - var scrollAction = function () { - var handleOffset = scrollbarVars.i.ho; - var handleLength = scrollbarVars.i.hl; - var mouseOffset = mouseDownOffset - trackOffset; - var scrollDuration = 200 * scrollDurationFactor; - var timeoutDelay = isFirstIteration ? Math.max(333, scrollDuration) : scrollDuration; - var scrollObj = {}; - var rtlIsNormal = _isRTL && isHorizontal && ((!_rtlScrollBehavior.i && !_rtlScrollBehavior.n) || _normalizeRTLCache); - var decreaseScrollCondition = handleOffset > mouseOffset; - - if (rtlIsNormal) - decreaseScrollCondition = handleOffset < mouseOffset; - - if (decreaseScrollCondition) { - if (decreaseScroll === undefined) - decreaseScroll = true; - scrollObj[scrollbarVars.xy] = '-=' + scrollDistance; - } - else { - if (decreaseScroll === undefined) - decreaseScroll = false; - scrollObj[scrollbarVars.xy] = '+=' + scrollDistance; - } - _base.scrollStop(); - _base.scroll(scrollObj, scrollDuration, 'linear'); - - var finishedCondition = decreaseScroll ? handleOffset <= mouseOffset : handleOffset + handleLength >= mouseOffset; - if (rtlIsNormal) - finishedCondition = decreaseScroll ? handleOffset + handleLength >= mouseOffset : handleOffset <= mouseOffset; - - if (finishedCondition) { - clearTimeout(trackTimeout); - _base.scrollStop(); - trackTimeout = undefined; - } - else - trackTimeout = setTimeout(scrollAction, timeoutDelay); - isFirstIteration = false; - }; - - mouseDownOffset = compatibility.page(event)[xy]; - _bodyElement.addClass(_classNameDragging); - scrollbarVars.t.addClass(strActive); - scrollbarVars.s.addClass(strActive); - - if (_supportPassiveEvents) { - addPassiveEventListener(_documentElement, _strMouseTouchUpEvent, documentMouseTouchUp); - addPassiveEventListener(_documentElement, _strKeyDownEvent, documentKeyDown); - addPassiveEventListener(_documentElement, _strKeyUpEvent, documentKeyUp); - } - else { - _documentElement.on(_strMouseTouchUpEvent, documentMouseTouchUp) - .on(_strKeyDownEvent, documentKeyDown) - .on(_strKeyUpEvent, documentKeyUp); - } - _documentElement.on(_strSelectStartEvent, onSelectStart); - - scrollAction(); - compatibility.prvD(event); - } - }).hover(function () { //make sure both scrollbars will stay visible if one scrollbar is hovered if autoHide is "scroll". - if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) { - _scrollbarsAutoHideFlagScrollAndHovered = true; - refreshScrollbarsAutoHide(true); - } - }, function () { - if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) { - _scrollbarsAutoHideFlagScrollAndHovered = false; - refreshScrollbarsAutoHide(false); - } - }); - scrollbarVars.s.on(_strMouseTouchDownEvent, function (event) { - compatibility.stpP(event); - }); - } - - /** - * 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 - }; - } - - /** - * 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) - 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; - - var optionsCallbacks = _currentPreparedOptions.callbacks; - var onScrollStartCallback = optionsCallbacks.onScrollStart; - var onScrollCallback = optionsCallbacks.onScroll; - var onScrollStopCallback = optionsCallbacks.onScrollStop; - if (_scrollStopTimeoutId !== undefined) - clearTimeout(_scrollStopTimeoutId); - else { - if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) - refreshScrollbarsAutoHide(true); - - if (!nativeOverlayScrollbarsAreActive()) - _hostElement.addClass(_classNameHostScrolling); - - if (helper.isFunction(onScrollStartCallback)) - callCallback(onScrollStartCallback, event); - } - - refreshScrollbarHandleOffset(true, _viewportElement[_strScrollLeft]()); - refreshScrollbarHandleOffset(false, _viewportElement[_strScrollTop]()); - - if (helper.isFunction(onScrollCallback)) - callCallback(onScrollCallback, event); - - _scrollStopTimeoutId = setTimeout(function () { - onScrollStop(event); - if (helper.isFunction(onScrollStopCallback)) - callCallback(onScrollStopCallback, event); - }, _scrollStopDelay); - } - - /** - * This method gets called if the scroll event stopped for a specified amount of time. - * @param event The last scroll event which was fired. - */ - function onScrollStop() { - clearTimeout(_scrollStopTimeoutId); - _scrollStopTimeoutId = undefined; - if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) - refreshScrollbarsAutoHide(false); - - if (!nativeOverlayScrollbarsAreActive()) - _hostElement.removeClass(_classNameHostScrolling); - } - - /** - * 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) { - return ( - typeof HTMLElement === TYPES.o ? o instanceof HTMLElement : //DOM2 - o && typeof o === TYPES.o && o !== null && o.nodeType === 1 && typeof o.nodeName === TYPES.s - ); - } - - /** - * Validates a given option and returns the result. - * @param currentOptions Current options object - * @param optionName The option name - * @param optionAllowedValues Allowed Values for this option - * @param removeFromObject Undefined or True to remove the option with the given option name from the given options object. - * @returns {{n: string, s: boolean, v: *, p: *}} - * n = option name - * s = true if option is valid, false otherwise - * v = the original value - * p = the prepared value (may only different from original value if typeof string) - */ - function getValidatedOption(currentOptions, optionName, optionAllowedValues, removeFromObject) { - var returnObj = {n: optionName, s: false, v: undefined, p: undefined}; //name = [name], succes = false, value = undefined, prepared = undefined, - var optionValue; - var optionValueType = TYPES.u; - var optionNameProgression = byPropertyPath.has(currentOptions, optionName); - var currObj = byPropertyPath.get(currentOptions, optionName); - var canBeUndefined = false; - var optionIsInvalid = optionNameProgression !== true; - var strStar = '*'; - var i, v, g; - var optionAllowedValuesLength; - var anyStringAllowed = false; - if (helper.type(optionAllowedValues) !== TYPES.a) - optionAllowedValues = [optionAllowedValues]; - optionAllowedValuesLength = optionAllowedValues.length; - - for (i = 0; i < optionAllowedValuesLength; i++) { - var curr = optionAllowedValues[i]; - if (curr === strStar) { - if (optionAllowedValuesLength > 1) { - var count = 0; - for (g = 0; g < optionAllowedValuesLength; g++) { - var check = optionAllowedValues[g]; - if (helper.type(check) === TYPES.s) { - count++; - if (count > 1) - break; - } - } - if (count === 1) - anyStringAllowed = true; - } - else - anyStringAllowed = true; - } - if (curr === undefined) - canBeUndefined = true; - } - - if (optionIsInvalid && optionNameProgression === false && canBeUndefined) - optionIsInvalid = false; - - if (!optionIsInvalid) { - optionValue = currObj; - optionValueType = helper.type(optionValue); - var checkOption = function (allowedValue) { - var valueType = helper.type(allowedValue); - var correct = false; - if (valueType === optionValueType) { - if (valueType === TYPES.s) { - correct = anyStringAllowed ? true : optionValue === allowedValue; - } - else { - correct = true; - } - if (correct) { - returnObj.s = true; - returnObj.v = optionValue; - returnObj.p = optionValue; - return true; - } - } - return false; - }; - for (i = 0; i < optionAllowedValuesLength; i++) { - var currPossibleValue = optionAllowedValues[i]; - if (helper.type(currPossibleValue) === TYPES.s) { - var currPossibleValueSplit = currPossibleValue.split(':'); - var key = currPossibleValueSplit[0]; - var breakAll = false; - for (v = 0; v < currPossibleValueSplit.length; v++) { - if (checkOption(currPossibleValueSplit[v])) { - if (!anyStringAllowed) - returnObj.p = key; - breakAll = true; - break; - } - } - if (breakAll) - break; - } - else { - if (checkOption(currPossibleValue)) - break; - } - } - } - if (!returnObj.s) { - var error = "The option \"" + optionName + "\" wasn't set, because"; - if (!optionIsInvalid || optionNameProgression === false) { - var allowedValueTypes = []; - var allowedValueTypesString = _strEmpty; - var hasAllowedStrings = false; - var allowedStringsText = _strEmpty; - for (i = 0; i < optionAllowedValuesLength; i++) { - var value = optionAllowedValues[i]; - var valueType = helper.type(value); - if (valueType === TYPES.s) { - hasAllowedStrings = !anyStringAllowed; - var stringSplit = value.split(':'); - for (v = 0; v < stringSplit.length; v++) { - allowedStringsText += "\"" + stringSplit[v] + "\", "; - } - } - if (helper.inArray(valueType, allowedValueTypes) === -1) { - allowedValueTypes.push(valueType); - allowedValueTypesString = allowedValueTypesString + valueType.toUpperCase() + ", "; - } - } - allowedValueTypesString = allowedValueTypesString.slice(0, -2); - if (hasAllowedStrings) - allowedStringsText = allowedStringsText.slice(0, -2); - console.warn(error + " it doesn't accept the type [ " + optionValueType.toUpperCase() + " ] with the value of \"" + optionValue + "\".\r\n" + - "Accepted types are: [ " + allowedValueTypesString + " ]." + - (hasAllowedStrings ? "\r\nValid strings are: [ " + allowedStringsText + " ]." : _strEmpty)); - } - else { - var isDefaultOption = byPropertyPath.has(_defaultOptions, optionName); - if (isDefaultOption === true) { - console.warn(error + " \"" + optionNameProgression + "\" is not from type [ OBJECT ]."); - } - else { - error = "The option \"" + optionName + "\" is not a default option"; - if (isDefaultOption === false) - console.warn(error + _strDot); - else - console.warn(error + " and couldn't be resolved, because \"" + isDefaultOption + "\" is not from type [ OBJECT ]."); - } - } - } - removeFromObject = removeFromObject === undefined ? true : removeFromObject; - if (removeFromObject) - byPropertyPath.del(currentOptions, optionName); - return returnObj; - } - - /** - * 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 = parseIntToZeroOrNumber(_contentArrangeElement.css(_strMinMinus + _strWidth)); - bodyMinSize.h = parseIntToZeroOrNumber(_contentArrangeElement.css(_strMinMinus + _strHeight)); - bodyMinSize.c = checkCacheDouble(bodyMinSize, _bodyMinSizeCache); - bodyMinSize.f = true; //flag for "measured at least once" - } - _bodyMinSizeCache = bodyMinSize; - return bodyMinSize.c; - } - - /** - * Builds a new object which consists of all valid options in the given options array. - * @param validatedOptionsArray The array of validated options - * @param usePreparedValues True for prepared values, False for original values (these two may only differ if they are typeof string) - * @returns {{}} A new object which consists of all valid options from the given array. - */ - function buildValidatedOptionsObject(validatedOptionsArray, usePreparedValues) { - var returnObj = {}; - var i, v; - for (i = 0; i < validatedOptionsArray.length; i++) { - var currValidatedOption = validatedOptionsArray[i]; - var objects = []; - if (currValidatedOption.s) { - var propertyString = currValidatedOption.n; - var propertyStingSplit = propertyString.split('.'); - - for (v = 0; v < propertyStingSplit.length; v++) { - objects[v] = {}; - objects[v][propertyStingSplit[v]] = {}; - } - for (v = 0; v < objects.length; v++) { - var set = false; - var currObj = objects[v]; - if (v + 1 === objects.length) - set = true; - - for (var property in currObj) { - if (currObj.hasOwnProperty(property)) { - currObj[property] = objects[v + 1]; - if (set) { - if (usePreparedValues) - currObj[property] = currValidatedOption.p; - else - currObj[property] = currValidatedOption.v; + v : function (obj, template, writeErrors, usePreparedValues, keepForeignProps) { + var validatedOptions = { }; + var objectCopy = helper.extend(true, { }, obj); + var checkObjectProps = function(data, template, validatedOptions, prevPropName) { + for (var prop in template) { + if (template.hasOwnProperty(prop) && data.hasOwnProperty(prop)) { + var isValid = false; + var templateValue = template[prop]; + var templateValueType = helper.type(templateValue); + var templateTypes = helper.type(templateValue) !== TYPES.a ? [ templateValue ] : templateValue; + var dataValue = data[prop]; + var dataValueType = helper.type(dataValue); + var propPrefix = prevPropName ? prevPropName + "." : ""; + var error = "The option \"" + propPrefix + prop + "\" wasn't set, because"; + var errorPossibleTypes = [ ]; + var errorRestrictedStrings = [ ]; + var restrictedStringValuesSplit; + var restrictedStringValuesPossibilitiesSplit; + var isRestrictedValue; + var mainPossibility; + var currType; + var i; + var v; + var j; + + //if the template has a object as value, it means that the options are complex (verschachtelt) + if(templateValueType === TYPES.o) { + validatedOptions[prop] = { }; + checkObjectProps(dataValue, templateValue, validatedOptions[prop], propPrefix + prop); + if(helper.isEmptyObject(dataValue)) + delete data[prop]; + } + else { + for(i = 0; i < templateTypes.length; i++) { + currType = templateTypes[i]; + templateValueType = helper.type(currType); + //if currtype is string and starts with restrictedStringPrefix and end with restrictedStringSuffix + isRestrictedValue = templateValueType === TYPES.s && helper.inArray(currType, possibleTemplateTypes) === -1; + if(isRestrictedValue) { + errorPossibleTypes.push(TYPES.s); + + //split it into a array which contains all possible values for example: ["y:yes", "n:no", "m:maybe"] + restrictedStringValuesSplit = currType.split(restrictedStringsSplit); + errorRestrictedStrings = errorRestrictedStrings.concat(restrictedStringValuesSplit); + for(v = 0; v < restrictedStringValuesSplit.length; v++) { + //split the possible values into their possibiliteis for example: ["y", "yes"] -> the first is always the mainPossibility + restrictedStringValuesPossibilitiesSplit = restrictedStringValuesSplit[v].split(restrictedStringsPossibilitiesSplit); + mainPossibility = restrictedStringValuesPossibilitiesSplit[0]; + for(j = 0; j < restrictedStringValuesPossibilitiesSplit.length; j++) { + //if any possibility matches with the dataValue, its valid + if(dataValue === restrictedStringValuesPossibilitiesSplit[j]) { + isValid = true; + break; + } + } + if(isValid) + break; + } + } + else { + errorPossibleTypes.push(currType); + + if(dataValueType === currType) { + isValid = true; + break; + } + } + } + + if(isValid) { + validatedOptions[prop] = isRestrictedValue && usePreparedValues ? mainPossibility : dataValue; + } + else if(writeErrors) { + console.warn(error + " it doesn't accept the type [ " + dataValueType.toUpperCase() + " ] with the value of \"" + dataValue + "\".\r\n" + + "Accepted types are: [ " + errorPossibleTypes.join(", ").toUpperCase() + " ]." + + (errorRestrictedStrings.length > 0 ? "\r\nValid strings are: [ " + errorRestrictedStrings.join(", ").split(restrictedStringsPossibilitiesSplit).join(", ") + " ]." : "")); + } + delete data[prop]; } } } + }; + checkObjectProps(objectCopy, template, validatedOptions); + + //add values which aren't specified in the template to the finished validated object to prevent them from being discarded + if(keepForeignProps) + helper.extend(true, validatedOptions, objectCopy); + else if(!helper.isEmptyObject(objectCopy) && writeErrors) + console.warn("The following options are discarded due to invalidity:\r\n" + JSON.stringify(objectCopy, null, 2)); + + return validatedOptions; + } + } + }()); + + /** + * Initializes the object which contains global information about the plugin and each instance of it. + */ + function initOverlayScrollbarsStatics() { + if(!_pluginsGlobals) + _pluginsGlobals = new OverlayScrollbarsGlobals(_pluginsOptions.d); + if(!_pluginsAutoUpdateLoop) + _pluginsAutoUpdateLoop = new OverlayScrollbarsAutoUpdateLoop(_pluginsGlobals); + } + + /** + * The global object for the hide scrollbars objects. It contains resources which every hide scrollbars object needs. This object is initialized only once: if the first hide scrollbars object gets initialized. + * @param defaultOptions + * @constructor + */ + function OverlayScrollbarsGlobals(defaultOptions) { + var _base = this; + var strOverflow = 'overflow'; + var strHidden = 'hidden'; + var strScroll = 'scroll'; + var bodyElement = helper('body'); + var scrollbarDummyElement = helper('
'); + var scrollbarDummyElement0 = scrollbarDummyElement[0]; + var dummyContainerChild = helper(scrollbarDummyElement.children('div').first()); + var IEBUGFIX = scrollbarDummyElement0[LEXICON.oH]; //IE9 causes a bug where offsetHeight is zero for no reason + + bodyElement.append(scrollbarDummyElement); + if(IEBUGFIX === 0) + scrollbarDummyElement.hide().show(); + + var nativeScrollbarSize = calcNativeScrollbarSize(scrollbarDummyElement0); + var nativeScrollbarIsOverlaid = { + x: nativeScrollbarSize.x === 0, + y: nativeScrollbarSize.y === 0 + }; + + helper.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 = false; + 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.style.cssText = 'width:' + prop + '(1px);'; + if (dummy.style.length) + return prop; } - helper.extend(true, returnObj, objects[0]); + 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 windowWidth = compatibility.wW(); + var windowHeight = compatibility.wH(); + var windowDpr = getWindowDPR(); + + function differenceIsBiggerThanOne(valOne, valTwo) { + var absValOne = Math.abs(valOne); + var absValTwo = Math.abs(valTwo); + return !(absValOne === absValTwo || absValOne + 1 === absValTwo || absValOne - 1 === absValTwo); } - } - return returnObj; - } - /** - * 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; - 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; + function getWindowDPR() { + var dDPI = window.screen.deviceXDPI || 0; + var sDPI = window.screen.logicalXDPI || 1; + return window.devicePixelRatio || (dDPI / sDPI); } - } - for (var k in a) { - diff.push(k); - } - return diff; - } - /** - * 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]; + helper(window).on('resize', function() { + if(instances.all().length > 0) { + var newW = compatibility.wW(); + var newH = compatibility.wH(); + var deltaW = newW - windowWidth; + var deltaH = newH - windowHeight; - //remove none theme from diff list to prevent update - var idx = helper.inArray(_classNameThemeNone, diff); - if (idx > -1) - diff.splice(idx, 1); + if (deltaW === 0 && deltaH === 0) + return; - for (var i = 0; i < diff.length; i++) { - var curr = diff[i]; - if (curr.indexOf(_classNameHostElement) !== 0) { - var v; - var o = true; - var c = true; - for (v = 0; v < oldClassNames.length; v++) { - if (curr === oldClassNames[v]) { - o = false; + var deltaWRatio = Math.round(newW / (windowWidth / 100.0)); + var deltaHRatio = Math.round(newH / (windowHeight / 100.0)); + var absDeltaW = Math.abs(deltaW); + var absDeltaH = Math.abs(deltaH); + var absDeltaWRatio = Math.abs(deltaWRatio); + var absDeltaHRatio = Math.abs(deltaHRatio); + var newDPR = getWindowDPR(); + + var deltaIsBigger = absDeltaW > 2 && absDeltaH > 2; + var difference = !differenceIsBiggerThanOne(absDeltaWRatio, absDeltaHRatio); + var dprChanged = newDPR !== windowDpr && windowDpr > 0; + var windowResized = !(deltaIsBigger && difference && dprChanged); + + if (!windowResized) { + bodyElement.append(scrollbarDummyElement); + _base.nativeScrollbarSize = calcNativeScrollbarSize(scrollbarDummyElement[0]); + scrollbarDummyElement.remove(); + helper.each(instances.all(), function () { + if(instances.has(this)) + instances.get(this).update('zoom'); + }); + } + + windowWidth = newW; + windowHeight = newH; + windowDpr = newDPR; + } + }); + })(); + + 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.style[featurename] !== undefined) + feature = true; + + if (!feature) { + featurenameCapital = featurename.charAt(0).toUpperCase() + featurename.substr(1); + for (; i < domPrefixes.length; i++) { + if (elm.style[domPrefixes[i] + featurenameCapital] !== undefined) { + feature = true; break; } } - for (v = 0; v < currClassNames.length; v++) { - if (curr === currClassNames[v]) { - c = false; - break; - } - } - if (o && c) { - changed = true; - break; - } } - + return feature; } - 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; - - if (mutationTarget === _contentElement[0]) - return attributeName === null; - if (mutationType === 'attributes' && (attributeName === WORDING.c || attributeName === WORDING.s) && !_isTextarea) { - //only do it of browser support it natively - if (typeof mutationTarget.closest !== TYPES.f) - return true; - if (mutationTarget.closest(_strDot + _classNameResizeObserverElement) !== null || - mutationTarget.closest(_strDot + _classNameScrollbar) !== null || - mutationTarget.closest(_strDot + _classNameScrollbarCorner) !== null) - return false; - } - return true; - } - - /** - * Sets new options but doesn't call the update method. - * @param newOptions The object which contains the new options. - */ - function setOptions(newOptions) { - newOptions = helper.extend(true, {}, _currentOptions, newOptions); - var classNameAllowedValues = ['*', null]; - var overflowBehaviorAllowedValues = ['v-h:visible-hidden', 'v-s:visible-scroll', 's:scroll', 'h:hidden']; - var scrollbarsVisibilityAllowedValues = ['v:visible', 'h:hidden', 'a:auto']; - var scrollbarsAutoHideAllowedValues = ['n:never', 's:scroll', 'l:leave', 'm:move']; - var resizeAllowedValues = ['n:none', 'b:both', 'h:horizontal', 'v:vertical']; - var strCallbacksDot = 'callbacks.'; - var strScrollbarsDot = _strScrollbar + 's.'; - var strTextareaDot = 'textarea.'; - var strOverflowBehaviorDot = 'overflowBehavior.'; - var strNativeScrollbarsOverlaidDot = 'nativeScrollbarsOverlaid.'; - - var booleanAllowedValues = true; - var booleanNullAllowedValues = [booleanAllowedValues, null]; - var numberAllowedValues = 0; - var callbackAllowedValues = [new Function(), null]; - - var validatedOptions = [ - getValidatedOption(newOptions, strNativeScrollbarsOverlaidDot + 'showNativeScrollbars', booleanAllowedValues), - getValidatedOption(newOptions, strNativeScrollbarsOverlaidDot + 'initialize', booleanAllowedValues), - getValidatedOption(newOptions, strOverflowBehaviorDot + _strX, overflowBehaviorAllowedValues), - getValidatedOption(newOptions, strOverflowBehaviorDot + _strY, overflowBehaviorAllowedValues), - getValidatedOption(newOptions, strScrollbarsDot + 'visibility', scrollbarsVisibilityAllowedValues), - getValidatedOption(newOptions, strScrollbarsDot + 'autoHide', scrollbarsAutoHideAllowedValues), - getValidatedOption(newOptions, strScrollbarsDot + 'autoHideDelay', numberAllowedValues), - getValidatedOption(newOptions, strScrollbarsDot + 'clickScrolling', booleanAllowedValues), - getValidatedOption(newOptions, strScrollbarsDot + 'dragScrolling', booleanAllowedValues), - getValidatedOption(newOptions, strScrollbarsDot + 'touchSupport', booleanAllowedValues), - getValidatedOption(newOptions, strTextareaDot + 'dynWidth', booleanAllowedValues), - getValidatedOption(newOptions, strTextareaDot + 'dynHeight', booleanAllowedValues), - getValidatedOption(newOptions, 'className', classNameAllowedValues), - getValidatedOption(newOptions, 'resize', resizeAllowedValues), - getValidatedOption(newOptions, 'sizeAutoCapable', booleanAllowedValues), - getValidatedOption(newOptions, 'paddingAbsolute', booleanAllowedValues), - getValidatedOption(newOptions, 'clipAlways', booleanAllowedValues), - getValidatedOption(newOptions, 'normalizeRTL', booleanAllowedValues), - getValidatedOption(newOptions, 'autoUpdate', booleanNullAllowedValues), - getValidatedOption(newOptions, 'autoUpdateInterval', numberAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onInitialized', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onInitializationWithdrawn', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onDestroyed', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onScrollStart', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onScroll', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onScrollStop', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onDirectionChanged', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onContentSizeChanged', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onHostSizeChanged', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onOverflowChanged', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onOverflowAmountChanged', callbackAllowedValues), - getValidatedOption(newOptions, strCallbacksDot + 'onUpdated', callbackAllowedValues) - ]; - - for (var prop in newOptions) { - if (newOptions.hasOwnProperty(prop)) { - if (byPropertyPath.has(_defaultOptions, prop)) { - if (helper.isEmptyObject(newOptions[prop])) - delete newOptions[prop]; - } - } - } - if (!helper.isEmptyObject(newOptions)) { - var prepare = function (obj) { - helper.each(obj, function (i, v) { - if (helper.isPlainObject(v)) - prepare(v); - else if (helper.type(v) === TYPES.f) - obj[i] = helper.type(v); - }); + function calcNativeScrollbarSize(measureElement) { + return { + x: measureElement[LEXICON.oH] - measureElement[LEXICON.cH], + y: measureElement[LEXICON.oW] - measureElement[LEXICON.cW] }; - prepare(newOptions); - console.warn("The following options are discarded due to invalidity:\r\n" + JSON.stringify(newOptions, null, 2)); } - - _currentOptions = helper.extend(true, {}, _currentOptions, buildValidatedOptionsObject(validatedOptions, false)); - _currentPreparedOptions = helper.extend(true, {}, _currentPreparedOptions, buildValidatedOptionsObject(validatedOptions, 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. + * The object which manages the auto update loop for all hide scrollbars objects. This object is initialized only once: if the first hide scrollbars object gets initialized. + * @constructor */ - function updateAutoContentSizeChanged() { - if (_isSleeping) - return false; + function OverlayScrollbarsAutoUpdateLoop(globals) { + var _base = this; + var _strAutoUpdate = 'autoUpdate'; + var _strAutoUpdateInterval = _strAutoUpdate + 'Interval'; - var textareaValueLength = _isTextarea && _widthAutoCache && !_textareaAutoWrappingCache ? _targetElement.val().length : 0; - var float; - var setCSS = !_mutationObserverConnected && _widthAutoCache && !_isTextarea; - var css = {}; - if (setCSS) { - float = _contentElement.css(_strFloat); - css[_strFloat] = _isRTL ? _strRight : _strLeft; - css[_strWidth] = _strAuto; - _contentElement.css(css); - } - var contentElementScrollSize = { - w: getContentMeasureElement()[WORDING.sW] + textareaValueLength, - h: getContentMeasureElement()[WORDING.sH] + textareaValueLength - }; - if (setCSS) { - css[_strFloat] = float; - css[_strWidth] = _strHundredPercent; - _contentElement.css(css); - } - var bodyMinSizeC = bodyMinSizeChanged(); - var changed = checkCacheDouble(contentElementScrollSize, _contentElementScrollSizeChangeDetectedCache) || bodyMinSizeC; - _contentElementScrollSizeChangeDetectedCache = contentElementScrollSize; + var _loopingInstances = [ ]; + var _loopingInstancesIntervalCache = [ ]; + var _loopIsActive = false; + var _loopIntervalDefault = 33; + var _loopInterval = _loopIntervalDefault; + var _loopTimeOld = compatibility.now(); + var _loopID; - return changed; - } + /** + * 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.length > 0 && _loopIsActive) { + _loopID = compatibility.rAF()(function () { + loop(); + }); + var timeNew = compatibility.now(); + var timeDelta = timeNew - _loopTimeOld; - /** - * 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(WORDING.i) || _strEmpty; - var hostElementIdChanged = checkCacheSingle(hostElementId, _updateAutoHostElementIdCache); - var hostElementClass = _hostElement.attr(WORDING.c) || _strEmpty; - var hostElementClassChanged = checkCacheSingle(hostElementClass, _updateAutoHostElementClassCache); - var hostElementStyle = _hostElement.attr(WORDING.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; - } - - /** - * Returns Zero or the number to which the value can be parsed. - * @param value The value which shall be parsed. - */ - function parseIntToZeroOrNumber(value) { - var num = window.parseInt(value); - return isNaN(num) ? 0 : num; - } - - /** - * 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 affectingPropsX = [ - _strWidth, - _strMinMinus + _strWidth, - _strMaxMinus + _strWidth, - _strMarginMinus + _strLeft, - _strMarginMinus + _strRight, - _strLeft, - _strRight, - 'font-weight', - 'word-spacing' - ]; - 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' - ]; - 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; + if (timeDelta > _loopInterval) { + _loopTimeOld = timeNew - (timeDelta % _loopInterval); + var lowestInterval = _loopIntervalDefault; + for(var i = 0; i < _loopingInstances.length; 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; } - 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; + /** + * 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(helper.inArray(instance, _loopingInstances) === -1) { + _loopingInstances.push(instance); + _loopingInstancesIntervalCache.push(compatibility.now()); + if (_loopingInstances.length > 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 = helper.inArray(instance, _loopingInstances); + if(index > -1) { + //remove from loopingInstances list + _loopingInstancesIntervalCache.splice(index, 1); + _loopingInstances.splice(index, 1); + + //correct update loop behavior + if (_loopingInstances.length === 0 && _loopIsActive) { + _loopIsActive = false; + globals.autoUpdateLoop = _loopIsActive; + if(_loopID !== undefined) { + compatibility.cAF()(_loopID); + _loopID = -1; + } + } + } + }; } /** - * Gets the element which is used to measure the content size. - * @returns {*} TextareaCover if target element is textarea else the ContentElement. + * 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 globals + * @param autoUpdateLoop + * @returns {*} + * @constructor */ - function getContentMeasureElement() { - return _isTextarea ? _textareaCoverElement[0] : _contentElement[0]; - } - - /** - * 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. - */ - function update(hostSizeChanged, contentSizeChanged, force) { - var now = compatibility.now(); - var swallow = _swallowUpdateLag > 0 && _initialized && (now - _lastUpdateTime) < _swallowUpdateLag && (!_heightAutoCache && !_widthAutoCache); - clearTimeout(_swallowedUpdateTimeout); - if (swallow) { - _swallowedUpdateParams.h = hostSizeChanged; - _swallowedUpdateParams.c = contentSizeChanged; - _swallowedUpdateParams.f = force; - _swallowedUpdateTimeout = setTimeout(update, _swallowUpdateLag); - } - - //abort update due to: - //swallowing - //sleeping - //host is hidden or has false display - if (swallow || _isSleeping || (_initialized && !force && _hostElement.is(':hidden')) || _hostElement.css('display') === 'inline') + function OverlayScrollbarsInstance(pluginTargetElement, options, globals, autoUpdateLoop) { + //if passed element is no HTML element: skip and return + if(!isHTMLElement(pluginTargetElement)) 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 arent 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 = helper.extend(true, {}, globals.nativeScrollbarSize); + //if passed element is already initialized: set passed options if there are any and return its instance + if(instances.has(pluginTargetElement)) { + var inst = instances.get(pluginTargetElement); + inst.options(options); + return inst; } - // 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 - }; + //make correct instanceof + var _base = new window[PLUGINNAME](); - freezeResizeObserver(_sizeObserverElement); - freezeResizeObserver(_sizeAutoObserverElement); + //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; - //save current scroll offset - var currScroll = { - l: _viewportElement[_strScrollLeft](), - t: _viewportElement[_strScrollTop]() - }; - var currentPreparedOptionsCallbacks = _currentPreparedOptions.callbacks; - var currentPreparedOptionsScrollbars = _currentPreparedOptions.scrollbars; - var currentPreparedOptionsTextarea = _currentPreparedOptions.textarea; + //general readonly: + var _initialized; + var _destroyed; + var _isTextarea; + var _isBody; - //callbacks - var onUpdated = currentPreparedOptionsCallbacks.onUpdated; - var onOverflowChanged = currentPreparedOptionsCallbacks.onOverflowChanged; - var onOverflowAmountChanged = currentPreparedOptionsCallbacks.onOverflowAmountChanged; - var onDirectionChanged = currentPreparedOptionsCallbacks.onDirectionChanged; - var onContentSizeChanged = currentPreparedOptionsCallbacks.onContentSizeChanged; - var onHostSizeChanged = currentPreparedOptionsCallbacks.onHostSizeChanged; + //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 = { }; - //scrollbars visibility: - var scrollbarsVisibility = currentPreparedOptionsScrollbars.visibility; - var scrollbarsVisibilityChanged = checkCacheSingle(scrollbarsVisibility, _scrollbarsVisibilityCache, force); + //scroll + var _scrollStopDelay = 175; + var _scrollStopTimeoutId; - //scrollbars autoHide: - var scrollbarsAutoHide = currentPreparedOptionsScrollbars.autoHide; - var scrollbarsAutoHideChanged = checkCacheSingle(scrollbarsAutoHide, _scrollbarsAutoHideCache, force); + //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'; + 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__'; - //scrollbars click scrolling - var scrollbarsClickScrolling = currentPreparedOptionsScrollbars.clickScrolling; - var scrollbarsClickScrollingChanged = checkCacheSingle(scrollbarsClickScrolling, _scrollbarsClickScrollingCache, force); + //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'; - //scrollbars drag scrolling - var scrollbarsDragScrolling = currentPreparedOptionsScrollbars.dragScrolling; - var scrollbarsDragScrollingChanged = checkCacheSingle(scrollbarsDragScrolling, _scrollbarsDragScrollingCache, force); + //options: + var _defaultOptions; + var _currentOptions; + var _currentPreparedOptions; - //className - var className = _currentPreparedOptions.className; - var classNameChanged = checkCacheSingle(className, _classNameCache, force); + //update + var _lastUpdateTime; + var _swallowedUpdateParams = { }; + var _swallowedUpdateTimeout; + var _swallowUpdateLag = 33; + var _imgs = [ ]; + + //DOM elements: + var _windowElement; + var _documentElement; + var _htmlElement; + var _bodyElement; + var _targetElement; //the target element of this hide scrollbars object + var _hostElement; //the host element of this hide scrollbars 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; + + //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 resize = _currentPreparedOptions.resize; - var resizeChanged = checkCacheSingle(resize, _resizeCache, force) && !_isBody; //body can't be resized since the window itself acts as resize possibility. + var _resizeReconnectMutationObserver; + var _resizeNone; + var _resizeBoth; + var _resizeHorizontal; + var _resizeVertical; + var _resizeDragStartPosition = { }; + var _resizeDragStartSize = { }; - //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); + //==== Add / Remove Passive Event Listener ====// - //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, textareaDynHeight); - - //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 = helper.extend(true, {}, overflowBehavior); - _textareaDynWidthCache = textareaDynWidth; - _textareaDynHeightCache = textareaDynHeight; - - //set correct class name to the host element - if (classNameChanged) { - _hostElement.removeClass(_oldClassName).removeClass(_classNameThemeNone); - if (className !== undefined && className !== null && className.length > 0) - _hostElement.addClass(className); - else - _hostElement.addClass(_classNameThemeNone); + /** + * 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}); } - //set correct auto Update - if (autoUpdateChanged) { - if (autoUpdate === true) { - mutationObserversDisconnect(); - autoUpdateLoop.add(_base); + /** + * 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); + } + + + //==== 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 (autoUpdate === null) { - if (_autoUpdateRecommended) { + 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 = helper(observerElement[strChildNodes][1]); + var expandElement = helper(observerElement[strChildNodes][0]); + var expandElementChild = helper(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)); + + helper(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 !== false; + 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().first().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).first()); + } + } + + /** + * 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).first(); + 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).first().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) + 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) { + var optionsCallbacks = _currentPreparedOptions.callbacks; + + if (_isSleeping) + return; + + if (_scrollStopTimeoutId !== undefined) + clearTimeout(_scrollStopTimeoutId); + else { + if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) + refreshScrollbarsAutoHide(true); + + if (!nativeOverlayScrollbarsAreActive()) + _hostElement.addClass(_classNameHostScrolling); + + callCallback(optionsCallbacks.onScrollStart, event); + } + + refreshScrollbarHandleOffset(true, _viewportElement[_strScrollLeft]()); + refreshScrollbarHandleOffset(false, _viewportElement[_strScrollTop]()); + callCallback(optionsCallbacks.onScroll, event); + + _scrollStopTimeoutId = setTimeout(function () { + viewportOnScrollStop(); + callCallback(optionsCallbacks.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()) + _hostElement.removeClass(_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 (helper.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 = helper.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 () { + 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); + + _bodyElement.addClass(_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); + + _bodyElement.removeClass(_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 = parseIntToZeroOrNumber(_contentArrangeElement.css(_strMinMinus + _strWidth)); + bodyMinSize.h = parseIntToZeroOrNumber(_contentArrangeElement.css(_strMinMinus + _strHeight)); + bodyMinSize.c = checkCacheDouble(bodyMinSize, _bodyMinSizeCache); + bodyMinSize.f = true; //flag for "measured at least once" + } + _bodyMinSizeCache = bodyMinSize; + return bodyMinSize.c; + } + + /** + * 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 = helper.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 textareaValueLength = _isTextarea && _widthAutoCache && !_textareaAutoWrappingCache ? _targetElement.val().length : 0; + var float; + var setCSS = !_mutationObserverConnected && _widthAutoCache && !_isTextarea; + var css = {}; + 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) || bodyMinSizeC; + _contentElementScrollSizeChangeDetectedCache = contentElementScrollSize; + + return changed; + } + + /** + * 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 affectingPropsX = [ + _strWidth, + _strMinMinus + _strWidth, + _strMaxMinus + _strWidth, + _strMarginMinus + _strLeft, + _strMarginMinus + _strRight, + _strLeft, + _strRight, + 'font-weight', + 'word-spacing' + ]; + 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' + ]; + 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. + */ + function update(hostSizeChanged, contentSizeChanged, force) { + var now = compatibility.now(); + var swallow = _swallowUpdateLag > 0 && _initialized && (now - _lastUpdateTime) < _swallowUpdateLag && (!_heightAutoCache && !_widthAutoCache); + clearTimeout(_swallowedUpdateTimeout); + if (swallow) { + _swallowedUpdateParams.h = hostSizeChanged; + _swallowedUpdateParams.c = contentSizeChanged; + _swallowedUpdateParams.f = force; + _swallowedUpdateTimeout = setTimeout(update, _swallowUpdateLag); + } + + //abort update due to: + //swallowing + //sleeping + //host is hidden or has false display + if (swallow || _isSleeping || (_initialized && !force && _hostElement.is(':hidden')) || _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 currentPreparedOptionsCallbacks = _currentPreparedOptions.callbacks; + var currentPreparedOptionsScrollbars = _currentPreparedOptions.scrollbars; + var currentPreparedOptionsTextarea = _currentPreparedOptions.textarea; + + //callbacks + var onUpdated = currentPreparedOptionsCallbacks.onUpdated; + var onOverflowChanged = currentPreparedOptionsCallbacks.onOverflowChanged; + var onOverflowAmountChanged = currentPreparedOptionsCallbacks.onOverflowAmountChanged; + var onDirectionChanged = currentPreparedOptionsCallbacks.onDirectionChanged; + var onContentSizeChanged = currentPreparedOptionsCallbacks.onContentSizeChanged; + var onHostSizeChanged = currentPreparedOptionsCallbacks.onHostSizeChanged; + + //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, textareaDynHeight); + + //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; + + //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(); } } - else { - autoUpdateLoop.remove(_base); - mutationObserversConnect(); - } - } - //activate or deactivate size auto capability - if (sizeAutoCapableChanged) { - if (sizeAutoCapable) { - if (_contentGlueElement === undefined) { - _contentGlueElement = helper(_strDivBegin + _classNameContentGlueElement + _strDivEnd); - _paddingElement.before(_contentGlueElement); - } - if (_sizeAutoObserverAdded) { - _sizeAutoObserverElement.show(); + //activate or deactivate size auto capability + if (sizeAutoCapableChanged) { + if (sizeAutoCapable) { + if (_contentGlueElement === undefined) { + _contentGlueElement = helper(generateDiv(_classNameContentGlueElement)); + _paddingElement.before(_contentGlueElement); + } + if (_sizeAutoObserverAdded) { + _sizeAutoObserverElement.show(); + } + else { + _sizeAutoObserverElement = helper(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 { - _sizeAutoObserverElement = helper(_strDivBegin + _classNameSizeAutoObserverElement + _strDivEnd); - _contentGlueElement.before(_sizeAutoObserverElement); - var oldSize = {w: -1, h: -1}; - addResizeObserver(_sizeAutoObserverElement, function () { - var newSize = { - w: _sizeAutoObserverElement[0][WORDING.oW], - h: _sizeAutoObserverElement[0][WORDING.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)'); + if (_sizeAutoObserverAdded) + _sizeAutoObserverElement.hide(); } } - else { + + //if force, update all resizeObservers too + if (force) { + _sizeObserverElement.find('*').trigger(_strScroll); if (_sizeAutoObserverAdded) - _sizeAutoObserverElement.hide(); + _sizeAutoObserverElement.find('*').trigger(_strScroll); } - } - //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 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 box-sizing: - var boxSizing = _hostElement.css('box-sizing'); - var boxSizingChanged = checkCacheSingle(boxSizing, _cssBoxSizingCache, force); + //detect padding: + var padding = { + c: force, + t: parseIntToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strTop)), + r: parseIntToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strRight)), + b: parseIntToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strBottom)), + l: parseIntToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strLeft)) + }; - //detect padding: - var padding = { - c: force, - t: parseIntToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strTop)), - r: parseIntToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strRight)), - b: parseIntToZeroOrNumber(_hostElement.css(_strPaddingMinus + _strBottom)), - l: parseIntToZeroOrNumber(_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; + } - //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]; - _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); - //detect width auto: - var widthAutoResizeDetection = false; - var widthAutoObserverDetection = (_sizeAutoObserverAdded && (_hostElement.css(_strFloat) !== 'none' /*|| _isTextarea */)) ? (Math.round(sizeAutoObserverElementBCRect.right - sizeAutoObserverElementBCRect.left) === 0) && (!paddingAbsolute ? (hostElement[WORDING.cW] - _paddingX) > 0 : true) : false; - if (sizeAutoCapable && !widthAutoObserverDetection) { - var tmpCurrHostWidth = hostElement[WORDING.oW]; - var tmpCurrContentGlueWidth = _contentGlueElement.css(_strWidth); - _contentGlueElement.css(_strWidth, _strAuto); - - var tmpNewHostWidth = hostElement[WORDING.oW]; - _contentGlueElement.css(_strWidth, tmpCurrContentGlueWidth); - widthAutoResizeDetection = tmpCurrHostWidth !== tmpNewHostWidth; - if (!widthAutoResizeDetection) { - _contentGlueElement.css(_strWidth, tmpCurrHostWidth + 1); - tmpNewHostWidth = hostElement[WORDING.oW]; + var tmpNewHostWidth = hostElement[LEXICON.oW]; _contentGlueElement.css(_strWidth, tmpCurrContentGlueWidth); widthAutoResizeDetection = tmpCurrHostWidth !== tmpNewHostWidth; - } - } - var widthAuto = (widthAutoObserverDetection || widthAutoResizeDetection) && sizeAutoCapable; - var widthAutoChanged = checkCacheSingle(widthAuto, _widthAutoCache, force); - var wasWidthAuto = !widthAuto && _widthAutoCache; - - //detect height auto: - var heightAuto = _sizeAutoObserverAdded ? (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 ? parseIntToZeroOrNumber(_hostElement.css(_strBorderMinus + _strTop + strMinusWidth)) : 0, - r: updateBorderX ? parseIntToZeroOrNumber(_hostElement.css(_strBorderMinus + _strRight + strMinusWidth)) : 0, - b: updateBorderY ? parseIntToZeroOrNumber(_hostElement.css(_strBorderMinus + _strBottom + strMinusWidth)) : 0, - l: updateBorderX ? parseIntToZeroOrNumber(_hostElement.css(_strBorderMinus + _strLeft + strMinusWidth)) : 0 - }; - - //detect margin: - var margin = { - c: force, - t: parseIntToZeroOrNumber(_hostElement.css(_strMarginMinus + _strTop)), - r: parseIntToZeroOrNumber(_hostElement.css(_strMarginMinus + _strRight)), - b: parseIntToZeroOrNumber(_hostElement.css(_strMarginMinus + _strBottom)), - l: parseIntToZeroOrNumber(_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 = { }; - - //set info for padding - _paddingX = padding.l + padding.r; - _paddingY = padding.t + padding.b; - 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 = parseIntToZeroOrNumber(cssMaxValue.h); //ih = integer height - cssMaxValue.iw = parseIntToZeroOrNumber(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 = { - w: paddingElement[WORDING.oW], - h: paddingElement[WORDING.oH] - }; - - //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 - (paddingAbsolute ? _paddingY : 0) + - (_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 - (paddingAbsolute ? _paddingX : 0) + - (_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][WORDING.cH]; - } - if (sizeAutoCapable) - _contentGlueElement.css(contentGlueElementCSS); - _contentElement.css(contentElementCSS); - - - //CHECKPOINT HERE ~ - contentElementCSS = {}; - contentGlueElementCSS = {}; - _hasOverflowCache = _hasOverflowCache || {x: false, y: false}; - - //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 || paddingAbsoluteChanged || textareaDynWidthChanged || textareaDynHeightChanged || 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 //it must be hidden if height is auto - : 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[WORDING.cW], - h: contentMeasureElement[WORDING.cH] - }; - var scrollSize = { - w: Math.max(contentMeasureElement[WORDING.sW], contentMeasureElementGuaranty[WORDING.sW]), - h: Math.max(contentMeasureElement[WORDING.sH], contentMeasureElementGuaranty[WORDING.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 - viewportElementResetCSS[_strBottom] = wasHeightAuto ? _strEmpty : resetBottomTmp; - viewportElementResetCSS[isRTLLeft] = wasWidthAuto ? _strEmpty : resetXTmp; - _viewportElement.css(viewportElementResetCSS); - - //measure and correct several sizes - //has to be clientSize because offsetSize respect borders. - var hostSize = { - w: hostElement[WORDING.cW], - h: hostElement[WORDING.cH] - }; - var contentGlueSize = { - w: Math.max(contentClientSize.w + (paddingAbsolute ? _paddingX : 0), hostSize.w - _paddingX) - (textareaDynWidth ? (_isTextarea && widthAuto ? _marginX + (!_isBorderBox ? _paddingX + _borderX : 0) : 0) : 0), - h: Math.max(contentClientSize.h + (paddingAbsolute ? _paddingY : 0), 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; + if (!widthAutoResizeDetection) { + _contentGlueElement.css(_strWidth, tmpCurrHostWidth + 1); + tmpNewHostWidth = hostElement[LEXICON.oW]; + _contentGlueElement.css(_strWidth, tmpCurrContentGlueWidth); + widthAutoResizeDetection = tmpCurrHostWidth !== tmpNewHostWidth; } + } + var widthAuto = (widthAutoObserverDetection || widthAutoResizeDetection) && sizeAutoCapable; + var widthAutoChanged = checkCacheSingle(widthAuto, _widthAutoCache, force); + var wasWidthAuto = !widthAuto && _widthAutoCache; - var maxWidth = contentGlueElementCSS[_strWidth] + (_isBorderBox ? _borderX : -_paddingX); - var maxHeight = contentGlueElementCSS[_strHeight] + (_isBorderBox ? _borderY : -_paddingX); - var textareaCoverCSS = {}; + //detect height auto: + var heightAuto = _sizeAutoObserverAdded ? (Math.round(sizeAutoObserverElementBCRect.bottom - sizeAutoObserverElementBCRect.top) === 0) /* && (!paddingAbsolute && (_msieVersion > 9 || !_msieVersion) ? true : true) */ : false; + var heightAutoChanged = checkCacheSingle(heightAuto, _heightAutoCache, force); + var wasHeightAuto = !heightAuto && _heightAutoCache; - //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; + //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 ? parseIntToZeroOrNumber(_hostElement.css(_strBorderMinus + _strTop + strMinusWidth)) : 0, + r: updateBorderX ? parseIntToZeroOrNumber(_hostElement.css(_strBorderMinus + _strRight + strMinusWidth)) : 0, + b: updateBorderY ? parseIntToZeroOrNumber(_hostElement.css(_strBorderMinus + _strBottom + strMinusWidth)) : 0, + l: updateBorderX ? parseIntToZeroOrNumber(_hostElement.css(_strBorderMinus + _strLeft + strMinusWidth)) : 0 + }; - //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; + //detect margin: + var margin = { + c: force, + t: parseIntToZeroOrNumber(_hostElement.css(_strMarginMinus + _strTop)), + r: parseIntToZeroOrNumber(_hostElement.css(_strMarginMinus + _strRight)), + b: parseIntToZeroOrNumber(_hostElement.css(_strMarginMinus + _strBottom)), + l: parseIntToZeroOrNumber(_hostElement.css(_strMarginMinus + _strLeft)) + }; - //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) { + //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 = { }; + + //set info for padding + _paddingX = padding.l + padding.r; + _paddingY = padding.t + padding.b; + 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 = parseIntToZeroOrNumber(cssMaxValue.h); //ih = integer height + cssMaxValue.iw = parseIntToZeroOrNumber(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) - textareaCoverCSS[_strWidth] = parseIntToZeroOrNumber(_textareaCoverElement.css(_strWidth)) - 1; - contentGlueElementCSS[_strWidth] -= 1; + setTopRightBottomLeft(textareaCSS, _strPaddingMinus); + else + setTopRightBottomLeft(contentElementCSS, _strPaddingMinus); } - if (heightAuto && (clientSize.h < _viewportSize.h || _isTextarea) && _paddingY === 0) { + else { + setTopRightBottomLeft(paddingElementCSS, _strEmpty); if (_isTextarea) - textareaCoverCSS[_strHeight] = parseIntToZeroOrNumber(_textareaCoverElement.css(_strHeight)) - 1; - contentGlueElementCSS[_strHeight] -= 1; + setTopRightBottomLeft(textareaCSS, _strPaddingMinus, [padding.t, padding.r, padding.b, padding.l]); + else + setTopRightBottomLeft(contentElementCSS, _strPaddingMinus, [padding.t, padding.r, padding.b, padding.l]); } - - //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); + _paddingElement.css(paddingElementCSS); + _targetElement.css(textareaCSS); } - 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 contentScrollSize = { - w: Math.max(contentMeasureElement[WORDING.sW], contentMeasureElementGuaranty[WORDING.sW]), - h: Math.max(contentMeasureElement[WORDING.sH], contentMeasureElementGuaranty[WORDING.sH]) - }; - if(hideOverflow4CorrectMeasuring) - _contentElement.css(strOverflow, _strEmpty); - if (contentBCRect.width !== undefined) { - var contentBCRectW = contentBCRect.width; - var contentBCRectH = contentBCRect.height; - var contentBCRectMargin = 0.001; - contentScrollSize.w += parseIntToZeroOrNumber(contentBCRectW + contentBCRectMargin) - contentBCRectW; - contentScrollSize.h += parseIntToZeroOrNumber(contentBCRectH + contentBCRectMargin) - contentBCRectH; - } - contentScrollSize.c = contentSizeChanged = checkCacheDouble(contentScrollSize, _contentScrollSizeCache, force); - _contentScrollSizeCache = contentScrollSize; - - //has to be clientSize because offsetSize respect borders. - hostSize = { - w: hostElement[WORDING.cW], - h: hostElement[WORDING.cH] - }; - hostSizeChanged = checkCacheDouble(hostSize, _hostSizeCache); - _hostSizeCache = hostSize; //viewport size is padding container because it never has padding, margin and a border. _viewportSize = { - w: paddingElement[WORDING.oW], - h: paddingElement[WORDING.oH] + w: paddingElement[LEXICON.oW], + h: paddingElement[LEXICON.oH] }; - 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 overflowBehaviorIsH = { - * x : overflowBehavior.x === 'h', - * y : overflowBehavior.y === 'h' - * }; - */ - var overflowAmount = { - x: Math.max(0, Math.round((contentScrollSize.w - hostSize.w + (paddingAbsolute ? _paddingX : 0)) * 100) / 100), - y: Math.max(0, Math.round((contentScrollSize.h - hostSize.h + (paddingAbsolute ? _paddingY : 0)) * 100) / 100) - }; - var hideOverflowForceTextarea = _isTextarea && (_viewportSize.w === 0 || _viewportSize.h === 0); - if (hideOverflowForceTextarea) { - overflowAmount.x = 0; - overflowAmount.y = 0; + //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 - (paddingAbsolute ? _paddingY : 0) + + (_isBorderBox ? -_borderY : _paddingY)) : _strEmpty); + contentElementCSS[_strHeight] = _strAuto; + } else if (heightAutoChanged || paddingAbsoluteChanged) { + contentElementCSS[_strMaxMinus + _strHeight] = _strEmpty; + contentElementCSS[_strHeight] = _strHundredPercent; } - 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 arrangeChanged = force; - var arrangeContent = {}; - 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) { - var borderDesign = 'px solid transparent'; - contentElementCSS[_strBorderMinus + isRTLRight] = _strEmpty; - contentElementCSS[_strMarginMinus + isRTLRight] = _strEmpty; - if (_nativeScrollbarIsOverlaid.x && hasOverflow.x && hideOverflow.xs) { - if (heightAuto) - contentElementCSS[_strMarginMinus + _strBottom] = ignoreOverlayScrollbarHiding ? _strEmpty : _overlayScrollbarDummySize.x; - if (!heightAuto && !ignoreOverlayScrollbarHiding) - contentElementCSS[_strBorderMinus + _strBottom] = _overlayScrollbarDummySize.x + borderDesign; - else - contentElementCSS[_strBorderMinus + _strBottom] = _strEmpty; - } - else { - arrangeContent.h = _strEmpty; - arrangeChanged = true; - contentElementCSS[_strBorderMinus + _strBottom] = _strEmpty; - contentElementCSS[_strMarginMinus + _strBottom] = _strEmpty; - } - if (_nativeScrollbarIsOverlaid.y && hasOverflow.y && hideOverflow.ys) { - if (widthAuto) - contentElementCSS[_strMarginMinus + isRTLLeft] = ignoreOverlayScrollbarHiding ? _strEmpty : _overlayScrollbarDummySize.y; - if (/* !widthAuto && */ !ignoreOverlayScrollbarHiding) - contentElementCSS[_strBorderMinus + isRTLLeft] = _overlayScrollbarDummySize.y + borderDesign; - else - contentElementCSS[_strBorderMinus + isRTLLeft] = _strEmpty; - } - else { - arrangeContent.w = _strEmpty; - arrangeChanged = true; - contentElementCSS[_strBorderMinus + isRTLLeft] = _strEmpty; - contentElementCSS[_strMarginMinus + isRTLLeft] = _strEmpty; - } - } - if (ignoreOverlayScrollbarHiding) { - arrangeContent.w = _strEmpty; - arrangeContent.h = _strEmpty; - arrangeChanged = true; - } - if (arrangeChanged) { - var contentArrangeElementCSS = {}; - contentArrangeElementCSS[_strWidth] = hideOverflow.y ? arrangeContent.w : _strEmpty; - contentArrangeElementCSS[_strHeight] = hideOverflow.x ? arrangeContent.h : _strEmpty; - - if (_contentArrangeElement === undefined) { - _contentArrangeElement = helper(_strDivBegin + _classNameContentArrangeElement + _strDivEnd); - _viewportElement.prepend(_contentArrangeElement); - } - _contentArrangeElement.css(contentArrangeElementCSS); - } - _contentElement.css(contentElementCSS); + if (widthAuto && (widthAutoChanged || paddingAbsoluteChanged || boxSizingChanged || cssMaxValue.c || padding.c || border.c || cssDirectionChanged)) { + if (cssMaxValue.cw) + contentElementCSS[_strMaxMinus + _strWidth] = + (cssMaxValue.cw ? (cssMaxValue.iw - (paddingAbsolute ? _paddingX : 0) + + (_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; - 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] = _strEmpty; - viewportElementCSS[_strMarginMinus + _strTop] = _strEmpty; - - viewportElementCSS[_strPaddingMinus + isRTLRight] = _strEmpty; - viewportElementCSS[_strMarginMinus + isRTLRight] = _strEmpty; - } - viewportElementCSS[_strPaddingMinus + isRTLLeft] = _strEmpty; - 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] = strHidden; - paddingElementCSS[strOverflowY] = strHidden; - } - } - else { - if (!clipAlways || (overflowBehaviorIsVH.x || overflowBehaviorIsVS.x || overflowBehaviorIsVH.y || overflowBehaviorIsVS.y)) { - //only un-hide if Textarea - if (_isTextarea) { - paddingElementCSS[strOverflowX] = _strEmpty; - paddingElementCSS[strOverflowY] = _strEmpty; - } - viewportElementCSS[strOverflowX] = strVisible; - 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.style; - elementStyle.webkitTransform = 'scale(1)'; - elementStyle.display = 'run-in'; - var dump = element[WORDING.oH]; - elementStyle.display = _strEmpty; - elementStyle.webkitTransform = _strEmpty; - } - //force hard redraw in webkit if native overlaid scrollbars shall appear - if (ignoreOverlayScrollbarHidingChanged && ignoreOverlayScrollbarHiding) { - _hostElement.hide(); - var dump = hostElement[WORDING.oH]; - _hostElement.show(); - } + contentElementCSS[_strWidth] = _strAuto; + contentElementCSS[_strFloat] = isRTLRight; } - - //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; - } + 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); - //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); + //CHECKPOINT HERE ~ + contentElementCSS = {}; + contentGlueElementCSS = {}; + _hasOverflowCache = _hasOverflowCache || {x: false, y: false}; - //add or remove rtl class name for styling purposes - if (cssDirectionChanged) { - if (_isRTL) - _hostElement.addClass(_classNameHostRTL); - else - _hostElement.removeClass(_classNameHostRTL); - } + //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 || paddingAbsoluteChanged || textareaDynWidthChanged || textareaDynHeightChanged || 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 //it must be hidden if height is auto + : heightAuto; //if there is not the restricted Measuring bug, it must be hidden if the height is auto - //manage the resize feature (CSS3 resize "polyfill" for this plugin) - if (_isBody) - _hostElement.addClass(_classNameHostResizeDisabled); - if (resizeChanged) { - var addCornerEvents = function () { - _scrollbarCornerElement.on(_strMouseTouchDownEvent, scrollbarCornerOnMouseDown); + //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 removeCornerEvents = function () { - _scrollbarCornerElement.off(_strMouseTouchDownEvent, scrollbarCornerOnMouseDown); + var scrollSize = { + w: Math.max(contentMeasureElement[LEXICON.sW], contentMeasureElementGuaranty[LEXICON.sW]), + h: Math.max(contentMeasureElement[LEXICON.sH], contentMeasureElementGuaranty[LEXICON.sH]) }; - if (_resizeNone) { - _hostElement.addClass(_classNameHostResizeDisabled); - _scrollbarCornerElement.removeClass(_classNameScrollbarCornerResize) - .removeClass(_classNameScrollbarCornerResizeB) - .removeClass(_classNameScrollbarCornerResizeH) - .removeClass(_classNameScrollbarCornerResizeV); - - removeCornerEvents(); - } - else { - _hostElement.removeClass(_classNameHostResizeDisabled); - _scrollbarCornerElement.addClass(_classNameScrollbarCornerResize); - if (_resizeBoth) - _scrollbarCornerElement.addClass(_classNameScrollbarCornerResizeB); - else if (_resizeHorizontal) - _scrollbarCornerElement.addClass(_classNameScrollbarCornerResizeH); - else if (_resizeVertical) - _scrollbarCornerElement.addClass(_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) { - _hostElement.removeClass(_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); - } - } + var contentClientSize = { + w: _isTextarea && textareaSize && !textareaDynWidth ? textareaSize.ow : widthAuto ? clientSize.w : scrollSize.w, + h: _isTextarea && textareaSize && !textareaDynHeight ? textareaSize.oh : heightAuto ? clientSize.h : scrollSize.h }; - 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); - } + + //apply the correct viewport style + viewportElementResetCSS[_strBottom] = wasHeightAuto ? _strEmpty : resetBottomTmp; + viewportElementResetCSS[isRTLLeft] = wasWidthAuto ? _strEmpty : resetXTmp; + _viewportElement.css(viewportElementResetCSS); + + //measure and correct several sizes + //has to be clientSize because offsetSize respect borders. + var hostSize = { + w: hostElement[LEXICON.cW], + h: hostElement[LEXICON.cH] }; - if (_scrollbarsAutoHideLeave || _scrollbarsAutoHideMove) { - removeMouseTouchEvents(); - addMouseTouchEvents(_scrollbarsAutoHideMove); + var contentGlueSize = { + w: Math.max(contentClientSize.w + (paddingAbsolute ? _paddingX : 0), hostSize.w - _paddingX) - (textareaDynWidth ? (_isTextarea && widthAuto ? _marginX + (!_isBorderBox ? _paddingX + _borderX : 0) : 0) : 0), + h: Math.max(contentClientSize.h + (paddingAbsolute ? _paddingY : 0), 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] = parseIntToZeroOrNumber(_textareaCoverElement.css(_strWidth)) - 1; + contentGlueElementCSS[_strWidth] -= 1; + } + if (heightAuto && (clientSize.h < _viewportSize.h || _isTextarea) && _paddingY === 0) { + if (_isTextarea) + textareaCoverCSS[_strHeight] = parseIntToZeroOrNumber(_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); } - else { - removeMouseTouchEvents(); + 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 contentScrollSize = { + w: Math.max(contentMeasureElement[LEXICON.sW], contentMeasureElementGuaranty[LEXICON.sW]), + h: Math.max(contentMeasureElement[LEXICON.sH], contentMeasureElementGuaranty[LEXICON.sH]) + }; + if(hideOverflow4CorrectMeasuring) + _contentElement.css(strOverflow, _strEmpty); + if (contentBCRect.width) { + var contentBCRectW = contentBCRect.width; + var contentBCRectH = contentBCRect.height; + var contentBCRectMargin = 0.001; + contentScrollSize.w += parseIntToZeroOrNumber(contentBCRectW + contentBCRectMargin) - contentBCRectW; + contentScrollSize.h += parseIntToZeroOrNumber(contentBCRectH + contentBCRectMargin) - contentBCRectH; } + contentScrollSize.c = contentSizeChanged = checkCacheDouble(contentScrollSize, _contentScrollSizeCache, force); + _contentScrollSizeCache = contentScrollSize; - if (_scrollbarsAutoHideNever) - refreshScrollbarsAutoHide(true); - else - refreshScrollbarsAutoHide(false, true); - } + //has to be clientSize because offsetSize respect borders. + hostSize = { + w: hostElement[LEXICON.cW], + h: hostElement[LEXICON.cH] + }; + hostSizeChanged = checkCacheDouble(hostSize, _hostSizeCache); + _hostSizeCache = hostSize; - //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); - } + //viewport size is padding container because it never has padding, margin and a border. + _viewportSize = { + w: paddingElement[LEXICON.oW], + h: paddingElement[LEXICON.oH] + }; - //manage interactivity - if (scrollbarsClickScrollingChanged) - refreshScrollbarsInteractive(true, scrollbarsClickScrolling); - if (scrollbarsDragScrollingChanged) - refreshScrollbarsInteractive(false, scrollbarsDragScrolling); + 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 overflowBehaviorIsH = { + * x : overflowBehavior.x === 'h', + * y : overflowBehavior.y === 'h' + * }; + */ + var overflowAmount = { + x: Math.max(0, Math.round((contentScrollSize.w - hostSize.w + (paddingAbsolute ? _paddingX : 0)) * 100) / 100), + y: Math.max(0, Math.round((contentScrollSize.h - hostSize.h + (paddingAbsolute ? _paddingY : 0)) * 100) / 100) + }; + var hideOverflowForceTextarea = _isTextarea && (_viewportSize.w === 0 || _viewportSize.h === 0); + if (hideOverflowForceTextarea) { + overflowAmount.x = 0; + 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; - //manage class name which indicates scrollable overflow - if (hideOverflow.x || hideOverflow.y) - _hostElement.addClass(_classNameHostOverflow); - else - _hostElement.removeClass(_classNameHostOverflow); - if (hideOverflow.x) - _hostElement.addClass(_classNameHostOverflowX); - else - _hostElement.removeClass(_classNameHostOverflowX); - if (hideOverflow.y) - _hostElement.addClass(_classNameHostOverflowY); - else - _hostElement.removeClass(_classNameHostOverflowY); + 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; - //handle scroll - if (_isTextarea && contentSizeChanged) { - var textareaInfo = getTextareaInfo(); - if (textareaInfo !== undefined) { - var textareaRowsChanged = _textareaInfoCache === undefined ? true : textareaInfo.rows !== _textareaInfoCache.rows; - var widestRow = textareaInfo.wRow; - var cursorRow = textareaInfo.cursorRow; - var cursorCol = textareaInfo.cursorCol; - var lastRow = textareaInfo.rows; - var lastCol = textareaInfo.cols; - var cursorPos = textareaInfo.pos; - var cursorMax = textareaInfo.max; - 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 native scrollbar is overlay at x OR y axis, prepare DOM + if (_nativeScrollbarIsOverlaid.x || _nativeScrollbarIsOverlaid.y) { + var arrangeChanged = force; + var arrangeContent = {}; + 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; - 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. + arrangeChanged = checkCacheSingle(arrangeContent, _arrangeContentSizeCache, force); + _arrangeContentSizeCache = arrangeContent; + } + + if (hasOverflow.c || hideOverflow.c || contentScrollSize.c || cssDirectionChanged || widthAutoChanged || heightAutoChanged || widthAuto || heightAuto || ignoreOverlayScrollbarHidingChanged) { + var borderDesign = 'px solid transparent'; + contentElementCSS[_strBorderMinus + isRTLRight] = _strEmpty; + contentElementCSS[_strMarginMinus + isRTLRight] = _strEmpty; + if (_nativeScrollbarIsOverlaid.x && hasOverflow.x && hideOverflow.xs) { + if (heightAuto) + contentElementCSS[_strMarginMinus + _strBottom] = ignoreOverlayScrollbarHiding ? _strEmpty : _overlayScrollbarDummySize.x; + if (!heightAuto && !ignoreOverlayScrollbarHiding) + contentElementCSS[_strBorderMinus + _strBottom] = _overlayScrollbarDummySize.x + borderDesign; else - _viewportElement[_strScrollLeft](doScroll.x); + contentElementCSS[_strBorderMinus + _strBottom] = _strEmpty; + } + else { + arrangeContent.h = _strEmpty; + arrangeChanged = true; + contentElementCSS[_strBorderMinus + _strBottom] = _strEmpty; + contentElementCSS[_strMarginMinus + _strBottom] = _strEmpty; + } + if (_nativeScrollbarIsOverlaid.y && hasOverflow.y && hideOverflow.ys) { + if (widthAuto) + contentElementCSS[_strMarginMinus + isRTLLeft] = ignoreOverlayScrollbarHiding ? _strEmpty : _overlayScrollbarDummySize.y; + if (/* !widthAuto && */ !ignoreOverlayScrollbarHiding) + contentElementCSS[_strBorderMinus + isRTLLeft] = _overlayScrollbarDummySize.y + borderDesign; + else + contentElementCSS[_strBorderMinus + isRTLLeft] = _strEmpty; + } + else { + arrangeContent.w = _strEmpty; + arrangeChanged = true; + contentElementCSS[_strBorderMinus + isRTLLeft] = _strEmpty; + contentElementCSS[_strMarginMinus + isRTLLeft] = _strEmpty; } } + if (ignoreOverlayScrollbarHiding) { + arrangeContent.w = _strEmpty; + arrangeContent.h = _strEmpty; + arrangeChanged = true; + } + if (arrangeChanged) { + var contentArrangeElementCSS = {}; + contentArrangeElementCSS[_strWidth] = hideOverflow.y ? arrangeContent.w : _strEmpty; + contentArrangeElementCSS[_strHeight] = hideOverflow.x ? arrangeContent.h : _strEmpty; + + if (_contentArrangeElement === undefined) { + _contentArrangeElement = helper(generateDiv(_classNameContentArrangeElement)); + _viewportElement.prepend(_contentArrangeElement); + } + _contentArrangeElement.css(contentArrangeElementCSS); + } + _contentElement.css(contentElementCSS); } - _textareaInfoCache = textareaInfo; - } - else if (!_isTextarea) { - if (_isRTL && _rtlScrollBehavior.i && _nativeScrollbarIsOverlaid.y && hasOverflow.x && _normalizeRTLCache) - currScroll.l += _contentBorderSize.w; - _viewportElement[_strScrollLeft](currScroll.l); - _viewportElement[_strScrollTop](currScroll.t); - } - if (cssDirectionChanged && helper.isFunction(onDirectionChanged)) { - callCallback(onDirectionChanged, { - isRTL: _isRTL, - dir: cssDirection - }); - } - if (hostSizeChanged && helper.isFunction(onHostSizeChanged)) { - callCallback(onHostSizeChanged, { - width: _hostSizeCache.w, - height: _hostSizeCache.h - }); - } - if (contentSizeChanged && helper.isFunction(onContentSizeChanged)) { - callCallback(onContentSizeChanged, { - width: _contentScrollSizeCache.w, - height: _contentScrollSizeCache.h - }); - } - if ((hasOverflow.c || hideOverflow.c) && helper.isFunction(onOverflowChanged)) { - callCallback(onOverflowChanged, { - x: hasOverflow.x, - y: hasOverflow.y, - xScrollable: hideOverflow.xs, - yScrollable: hideOverflow.ys, - clipped: hideOverflow.x || hideOverflow.y - }); - } - if (overflowAmount.c && helper.isFunction(onOverflowAmountChanged)) { - callCallback(onOverflowAmountChanged, { - x: overflowAmount.x, - y: overflowAmount.y - }); - } - } + 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(); + } - //fix body min size - if (_isBody && (hasOverflow.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 && hasOverflow.x) - _contentElement.css(_strMinMinus + _strWidth, _bodyMinSizeCache.w + _overlayScrollbarDummySize.y); - if (_nativeScrollbarIsOverlaid.x && hasOverflow.y) - _contentElement.css(_strMinMinus + _strHeight, _bodyMinSizeCache.h + _overlayScrollbarDummySize.x); - _bodyMinSizeCache.c = false; - } - unfreezeResizeObserver(_sizeObserverElement); - unfreezeResizeObserver(_sizeAutoObserverElement); + // 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; - if (helper.isFunction(onUpdated)) { - callCallback(onUpdated, { - forced: force - }); - } - } + viewportElementCSS[_strPaddingMinus + isRTLRight] = _nativeScrollbarMinSize.y; + viewportElementCSS[_strMarginMinus + isRTLRight] = -_nativeScrollbarMinSize.y; + } + else { + viewportElementCSS[_strPaddingMinus + _strTop] = _strEmpty; + viewportElementCSS[_strMarginMinus + _strTop] = _strEmpty; - /** - * 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; - }; + viewportElementCSS[_strPaddingMinus + isRTLRight] = _strEmpty; + viewportElementCSS[_strMarginMinus + isRTLRight] = _strEmpty; + } + viewportElementCSS[_strPaddingMinus + isRTLLeft] = _strEmpty; + viewportElementCSS[_strMarginMinus + isRTLLeft] = _strEmpty; - /** - * 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" 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 isZoom = force === 'zoom'; - var imgElementSelector = 'img'; - var imgElementLoadEvent = 'load'; - if (force === _strAuto) { - attrsChanged = meaningfulAttrsChanged(); - contentSizeC = updateAutoContentSizeChanged(); - if (attrsChanged || contentSizeC) - update(false, contentSizeC); - } - else if (isZoom) { - update(true, true); - } - else { - force = _isSleeping || force; - _isSleeping = false; - update(false, false, force); - } - if(!_isTextarea && !isZoom) { - _contentElement.find(imgElementSelector).each(function(i, el) { - var index = helper.inArray(el, _imgs); - if (index === -1) { - el = helper(el); - el.off(imgElementLoadEvent, onImgLoad).on(imgElementLoadEvent, onImgLoad); + //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] = strHidden; + paddingElementCSS[strOverflowY] = strHidden; + } + } + else { + if (!clipAlways || (overflowBehaviorIsVH.x || overflowBehaviorIsVS.x || overflowBehaviorIsVH.y || overflowBehaviorIsVS.y)) { + //only un-hide if Textarea + if (_isTextarea) { + paddingElementCSS[strOverflowX] = _strEmpty; + paddingElementCSS[strOverflowY] = _strEmpty; + } + viewportElementCSS[strOverflowX] = strVisible; + 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.style; + elementStyle.webkitTransform = 'scale(1)'; + elementStyle.display = 'run-in'; + var dump = element[LEXICON.oH]; + elementStyle.display = _strEmpty; + 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(); + } } - }); - } - }; - /** - 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 (helper.isEmptyObject(newOptions) || !helper.isPlainObject(newOptions)) { - if (helper.type(newOptions) === TYPES.s) { - if (arguments.length >= 2) { - var option = {}; - byPropertyPath.set(option, newOptions, value, true); - setOptions(option); - update(); - return; + //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); + + //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); + } + } + }; + 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); + + //manage class name which indicates scrollable overflow + if (hideOverflow.x || hideOverflow.y) + addClass(_hostElement, _classNameHostOverflow); else - return byPropertyPath.get(_currentOptions, newOptions); + removeClass(_hostElement, _classNameHostOverflow); + if (hideOverflow.x) + addClass(_hostElement, _classNameHostOverflowX); + else + removeClass(_hostElement, _classNameHostOverflowX); + if (hideOverflow.y) + addClass(_hostElement, _classNameHostOverflowY); + else + removeClass(_hostElement, _classNameHostOverflowY); + + //handle scroll + if (_isTextarea && contentSizeChanged) { + var textareaInfo = getTextareaInfo(); + if (textareaInfo !== undefined) { + var textareaRowsChanged = _textareaInfoCache === undefined ? true : textareaInfo.rows !== _textareaInfoCache.rows; + var widestRow = textareaInfo.wRow; + var cursorRow = textareaInfo.cursorRow; + var cursorCol = textareaInfo.cursorCol; + var lastRow = textareaInfo.rows; + var lastCol = textareaInfo.cols; + var cursorPos = textareaInfo.pos; + var cursorMax = textareaInfo.max; + 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 && (hasOverflow.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 && hasOverflow.x) + _contentElement.css(_strMinMinus + _strWidth, _bodyMinSizeCache.w + _overlayScrollbarDummySize.y); + if (_nativeScrollbarIsOverlaid.x && hasOverflow.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 = helper(generateDiv(_classNameScrollbar + _strSpace + _classNameScrollbarHorizontal)); + _scrollbarHorizontalTrackElement = helper(generateDiv(_classNameScrollbarTrack)); + _scrollbarHorizontalHandleElement = helper(generateDiv(_classNameScrollbarHandle)); + _scrollbarVerticalElement = helper(generateDiv(_classNameScrollbar + _strSpace + _classNameScrollbarVertical)); + _scrollbarVerticalTrackElement = helper(generateDiv(_classNameScrollbarTrack)); + _scrollbarVerticalHandleElement = helper(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 = helper(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 mouseDownScroll; + var mouseDownOffset; + var xy = scrollbarVars.xy; + var scroll = _strScroll + scrollbarVars.LT; + var strActive = 'active'; + var trackTimeout; + var scrollDurationFactor = 1; + var increaseTrackScrollAmount = function () { + scrollDurationFactor = 0.5; + }; + var decreaseTrackScrollAmount = function () { + scrollDurationFactor = 1; + }; + var handleDragMove = function (event) { + var trackLength = scrollbarVars.i.tl; + var handleLength = scrollbarVars.i.hl; + var scrollRange = scrollbarVars.i.ms; + var scrollRaw = (handleLength / 2) + compatibility.page(event)[xy] - mouseDownOffset; + var scrollDeltaPercent = (scrollRaw - (handleLength / 2)) / (trackLength - handleLength); + var scrollDelta = (scrollRange * scrollDeltaPercent); + scrollDelta = isFinite(scrollDelta) ? scrollDelta : 0; + if (_isRTL && isHorizontal && (_rtlScrollBehavior.n || !_rtlScrollBehavior.n && !_rtlScrollBehavior.i)) + scrollDelta *= -1; + _viewportElement[scroll](mouseDownScroll + scrollDelta); + + if (!_supportPassiveEvents) + compatibility.prvD(event); + }; + var documentMouseTouchUp = function (event) { + event = event || event.originalEvent; + removeClass(_bodyElement, _classNameDragging); + removeClass(scrollbarVars.h, strActive); + removeClass(scrollbarVars.t, strActive); + removeClass(scrollbarVars.s, strActive); + + if (_supportPassiveEvents) { + removePassiveEventListener(_documentElement, _strMouseTouchMoveEvent, handleDragMove); + removePassiveEventListener(_documentElement, _strMouseTouchUpEvent, documentMouseTouchUp); + removePassiveEventListener(_documentElement, _strKeyDownEvent, documentKeyDown); + removePassiveEventListener(_documentElement, _strKeyUpEvent, documentKeyUp); + } + else { + _documentElement.off(_strMouseTouchMoveEvent, handleDragMove) + .off(_strMouseTouchUpEvent, documentMouseTouchUp) + .off(_strKeyDownEvent, documentKeyDown) + .off(_strKeyUpEvent, documentKeyUp); + } + _documentElement.off(_strSelectStartEvent, documentOnSelectStart); + + decreaseTrackScrollAmount(); + mouseDownScroll = undefined; + mouseDownOffset = undefined; + if (trackTimeout !== undefined) { + _base.scrollStop(); + clearTimeout(trackTimeout); + trackTimeout = undefined; + } + + //if mouse is outside host element + var rect = _hostElement[0].getBoundingClientRect(); + if (!(event.clientX >= rect.left && event.clientX <= rect.right && + event.clientY >= rect.top && event.clientY <= rect.bottom)) { + hostOnMouseLeave(); + } + if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) + refreshScrollbarsAutoHide(false); + }; + var documentKeyDown = function (event) { + if (event.keyCode == 16) + increaseTrackScrollAmount(); + }; + var documentKeyUp = function (event) { + if (event.keyCode == 16) + decreaseTrackScrollAmount(); + }; + scrollbarVars.h.on(_strMouseTouchDownEvent, function (event) { + if (_isSleeping) + return; + + var originalEvent = event.originalEvent || event; + var isTouchEvent = originalEvent.touches !== undefined; + if (nativeOverlayScrollbarsAreActive() || !_scrollbarsDragScrollingCache || (isTouchEvent && !_scrollbarsTouchSupport)) + return; + + if (compatibility.mBtn(event) === 1 || isTouchEvent) { + mouseDownScroll = _viewportElement[scroll](); + mouseDownScroll = mouseDownScroll === undefined ? 0 : mouseDownScroll; + if (_isRTL && isHorizontal && !_rtlScrollBehavior.n || !_isRTL) + mouseDownScroll = mouseDownScroll < 0 ? 0 : mouseDownScroll; + mouseDownOffset = compatibility.page(event)[xy]; + + + addClass(_bodyElement, _classNameDragging); + addClass(scrollbarVars.h, strActive); + addClass(scrollbarVars.s, strActive); + + if (_supportPassiveEvents) { + addPassiveEventListener(_documentElement, _strMouseTouchMoveEvent, handleDragMove); + addPassiveEventListener(_documentElement, _strMouseTouchUpEvent, documentMouseTouchUp); + } + else { + _documentElement.on(_strMouseTouchMoveEvent, handleDragMove) + .on(_strMouseTouchUpEvent, documentMouseTouchUp); + } + _documentElement.on(_strSelectStartEvent, documentOnSelectStart); + compatibility.prvD(event); + } + }); + scrollbarVars.t.on(_strMouseTouchDownEvent, function (event) { + if (_isSleeping) + return; + + var originalEvent = event.originalEvent || event; + var isTouchEvent = originalEvent.touches !== undefined; + if (nativeOverlayScrollbarsAreActive() || !_scrollbarsClickScrollingCache || (isTouchEvent && !_scrollbarsTouchSupport)) + return; + + if (compatibility.mBtn(event) === 1 || isTouchEvent) { + var scrollDistance = _viewportSize[scrollbarVars._wh]; + var trackOffset = scrollbarVars.t.offset()[scrollbarVars.lt]; + var decreaseScroll; + var isFirstIteration = true; + if (event.shiftKey) + increaseTrackScrollAmount(); + var scrollAction = function () { + var handleOffset = scrollbarVars.i.ho; + var handleLength = scrollbarVars.i.hl; + var mouseOffset = mouseDownOffset - trackOffset; + var scrollDuration = 200 * scrollDurationFactor; + var timeoutDelay = isFirstIteration ? Math.max(333, scrollDuration) : scrollDuration; + var scrollObj = {}; + var rtlIsNormal = _isRTL && isHorizontal && ((!_rtlScrollBehavior.i && !_rtlScrollBehavior.n) || _normalizeRTLCache); + var decreaseScrollCondition = handleOffset > mouseOffset; + + if (rtlIsNormal) + decreaseScrollCondition = handleOffset < mouseOffset; + + if (decreaseScrollCondition) { + if (decreaseScroll === undefined) + decreaseScroll = true; + scrollObj[scrollbarVars.xy] = '-=' + scrollDistance; + } + else { + if (decreaseScroll === undefined) + decreaseScroll = false; + scrollObj[scrollbarVars.xy] = '+=' + scrollDistance; + } + _base.scrollStop(); + _base.scroll(scrollObj, scrollDuration, 'linear'); + + var finishedCondition = decreaseScroll ? handleOffset <= mouseOffset : handleOffset + handleLength >= mouseOffset; + if (rtlIsNormal) + finishedCondition = decreaseScroll ? handleOffset + handleLength >= mouseOffset : handleOffset <= mouseOffset; + + if (finishedCondition) { + clearTimeout(trackTimeout); + _base.scrollStop(); + trackTimeout = undefined; + } + else + trackTimeout = setTimeout(scrollAction, timeoutDelay); + isFirstIteration = false; + }; + + mouseDownOffset = compatibility.page(event)[xy]; + + addClass(_bodyElement, _classNameDragging); + addClass(scrollbarVars.t, strActive); + addClass(scrollbarVars.s, strActive); + + if (_supportPassiveEvents) { + addPassiveEventListener(_documentElement, _strMouseTouchUpEvent, documentMouseTouchUp); + addPassiveEventListener(_documentElement, _strKeyDownEvent, documentKeyDown); + addPassiveEventListener(_documentElement, _strKeyUpEvent, documentKeyUp); + } + else { + _documentElement.on(_strMouseTouchUpEvent, documentMouseTouchUp) + .on(_strKeyDownEvent, documentKeyDown) + .on(_strKeyUpEvent, documentKeyUp); + } + _documentElement.on(_strSelectStartEvent, documentOnSelectStart); + + scrollAction(); + compatibility.prvD(event); + } + }).hover(function () { //make sure both scrollbars will stay visible if one scrollbar is hovered if autoHide is "scroll". + if (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove) { + _scrollbarsAutoHideFlagScrollAndHovered = true; + refreshScrollbarsAutoHide(true); + } + }, 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) + _hostElement.removeClass(scrollbarClassName); + else + _hostElement.addClass(scrollbarClassName); + + if (canScroll) + scrollbarElement.removeClass(_classNameScrollbarUnusable); + else + scrollbarElement.addClass(_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) + _scrollbarHorizontalElement.removeClass(_classNameScrollbarAutoHidden); + //if(_hasOverflowCache.y && _hideOverflowCache.ys) + _scrollbarVerticalElement.removeClass(_classNameScrollbarAutoHidden); + } + else { + var strActive = 'active'; + var hide = function () { + if (!_scrollbarsAutoHideFlagScrollAndHovered) { + var anyActive = _scrollbarHorizontalHandleElement.hasClass(strActive) || _scrollbarVerticalHandleElement.hasClass(strActive); + if (!anyActive && (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove || _scrollbarsAutoHideLeave)) + _scrollbarHorizontalElement.addClass(_classNameScrollbarAutoHidden); + if (!anyActive && (_scrollbarsAutoHideScroll || _scrollbarsAutoHideMove || _scrollbarsAutoHideLeave)) + _scrollbarVerticalElement.addClass(_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); + + //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 * 100000) / 100000) + "%"; //the last * 100000 / 100000 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 posRatio; + var handleLength = scrollbarVars.i.hl; + var trackLength = scrollbarVars.t[0]['offset' + scrollbarVars.WH]; + var handleTrackDiff = trackLength - handleLength; + var offset = handleTrackDiff; + + //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.n || !_rtlScrollBehavior.n && !_rtlScrollBehavior.i)) + offset = trackLength - handleLength - offset; + offset = Math.max(0, offset); + + if (_supportTransform) { + if (isRTLisHorizontal) + offset = -(trackLength - handleLength - offset); + translateValue = isHorizontal ? strTranslateBrace + offset + 'px, 0px)' : strTranslateBrace + '0px, ' + offset + 'px)'; + handleCSS['-webkit-' + strTransform] = translateValue; + handleCSS['-moz-' + strTransform] = translateValue; + handleCSS['-ms-' + strTransform] = translateValue; + handleCSS['-o-' + strTransform] = translateValue; + handleCSS[strTransform] = translateValue; } else - return _currentOptions; - } - setOptions(newOptions); - var isSleepingTmp = _isSleeping || false; - _isSleeping = false; - update(); - _isSleeping = isSleepingTmp; - }; + handleCSS[scrollbarVars.lt] = offset; + //only apply css if offset has changed and overflow exists. - /** - * 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); + if (!nativeOverlayScrollbarsAreActive()) + scrollbarVars.h.css(handleCSS); - _sizeObserverElement.remove(); - if (_contentGlueElement !== undefined) - _contentGlueElement.remove(); - if (_contentArrangeElement !== undefined) - _contentArrangeElement.remove(); - if (_sizeAutoObserverAdded) - _sizeAutoObserverElement.remove(); - - 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); + scrollbarVars.i.ho = offset; //ho = handle offset + scrollbarVars.i.tl = trackLength; //tl = track length } - _scrollbarHorizontalElement.remove(); - _scrollbarVerticalElement.remove(); - if(_scrollbarCornerElement) - _scrollbarCornerElement.remove(); - if (!_resizeNone) - scrollbarCornerOnResized(); + /** + * 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; - _contentElement.contents() - .unwrap() - .unwrap() - .unwrap(); - - if (_isBody) - _htmlElement.removeClass(_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); - } - - _textareaCoverElement.remove(); - _targetElement.removeClass(_classNameTextareaElement) - .removeClass(_classNameTextInherit) - .unwrap() - .removeAttr(WORDING.s); - _hostElement.remove(); + element1[action](className); + element2[action](className); } - else { - _targetElement.removeClass(_classNameHostElement); - _hostElement.removeClass(_classNameHostElement) - .removeClass(_classNameHostResizeDisabled) - .removeClass(_classNameHostRTL) - .removeClass(_classNameHostScrollbarHorizontalHidden) - .removeClass(_classNameHostScrollbarVerticalHidden) - .removeClass(_classNameHostTransition) - .removeClass(_classNameHostScrolling) - .removeClass(_classNameHostOverflow) - .removeClass(_classNameHostOverflowX) - .removeClass(_classNameHostOverflowY) - .removeClass(_classNameThemeNone) - .removeClass(_classNameCache); - } - - for(var i = 0; i < _imgs.length; i++) - helper(_imgs[i]).off('load', onImgLoad); - _imgs = undefined; - - instances.rem(pluginTargetElement); - var onDestroyed = _currentPreparedOptions.callbacks.onDestroyed; - if (helper.isFunction(onDestroyed)) - 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 defined, else this object isn't valid. - * axis : [string], Default value is 'xy'. - * block : [string], Default value is 'begin'. - * margin : [number, array, boolean] Default value is false. - * } - * - * Possible axis settings are: - * 'x' Scrolls only the x axis. - * 'y' Scrolls only the y axis. - * 'xy' Scrolls both axis. - * 'yx' Same as 'xy' - * - * 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 edges. - * [ string, string ] Specify Begin or End for each axis individually. - * - * Possible margin settings are: -- The actual margin of the element wont be affect, this option affects only the final scroll offset. - * true The true margin of the element will be used. - * false No margin will be used. - * [NUMBER] The margin will be used for all edges. - * [ [NUMBER], [NUMBER] ] The first margin number will be used for the margin of the X axis egdes (left and right) and the second number will be used for the Y axis edges (top and bottom). - * [ [NUMBER], [NUMBER],[NUMBER], [NUMBER] ] Each edge gets its own margin value, the first value stays for the top margin, the second for the right margin, the third for the bottom margin and the forth for the left margin. - * - * @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; + /** + * 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 { - 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 - } + 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 }; } - var coordinatesXAxisProps = [_strX, _strLeft, 'l']; - var coordinatesYAxisProps = [_strY, _strTop, 't']; - var coordinatesOperators = ['+=', '-=', '*=', '/=']; - var i; - var finalScroll = { }; - var durationIsObject = helper.type(duration) === TYPES.o; - var strEnd = 'end'; - var strBegin = 'begin'; - var strCenter = 'center'; - var strNearest = 'nearest'; - var elementObjSettings = { - axis: 'xy', - block: [strBegin, strBegin], - margin: [0, 0, 0, 0] - }; - var elementObjSettingsAxisValues = [_strX, _strY, 'xy', 'yx']; - var elementObjSettingsBlockValues = [strBegin, strEnd, strCenter, strNearest]; - var coordinatesIsElementObj = coordinates.hasOwnProperty('el'); - var possibleElement = coordinatesIsElementObj ? coordinates.el : coordinates; - var possibleElementIsJQuery = possibleElement instanceof helper || possibleElement instanceof window.jQuery; - var possibleElementIsHTMLElement = possibleElementIsJQuery ? false : isHTMLElement(possibleElement); - var checkSettingsStringValue = function (currValue, allowedValues) { - for (i = 0; i < allowedValues.length; i++) { - if (currValue === allowedValues[i]) + + //==== Utils ====// + + /** + * Calls the given callback with the given args. The Context of this callback is always _base (this). + * @param callback The callback function which shall be called. + * @param args The args with which the callback shall be called. + */ + function callCallback(callback, args) { + if(_initialized && helper.isFunction(callback)) + callback.call(_base, 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) { + return ( + typeof window.HTMLElement === TYPES.o ? o instanceof window.HTMLElement : //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; + 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 (var 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. + */ + function parseIntToZeroOrNumber(value) { + var num = 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.prop('selectionStart'); + if (textareaCursorPosition === undefined) + return; + var textareaValue = _targetElement.val(); + var textareaLength = textareaValue.length; + var textareaRowSplit = textareaValue.split("\n"); + var textareaLastRow = textareaRowSplit.length; + var textareaCurrentCursorRowSplit = textareaValue.substr(0, textareaCursorPosition).split("\n"); + var widestRow = 0; + var textareaLastCol = 0; + var cursorRow = textareaCurrentCursorRowSplit.length; + var cursorCol = textareaCurrentCursorRowSplit[textareaCurrentCursorRowSplit.length - 1].length; + var rowCols; + var i; + + //get widest Row and the last column of the textarea + for (i = 0; i < textareaRowSplit.length; i++) { + rowCols = textareaRowSplit[i].length; + if (rowCols > textareaLastCol) { + widestRow = i + 1; + textareaLastCol = rowCols; + } + } + + return { + cursorRow: cursorRow, + cursorCol: cursorCol, + rows: textareaLastRow, + cols: textareaLastCol, + wRow: widestRow, + pos: textareaCursorPosition, + max: textareaLength + }; + } + + /** + * 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; - }; - var getRawScroll = function (coordinates) { - var rawScroll = {}; - if (helper.type(coordinates) === TYPES.a && coordinates.length > 0) { - rawScroll.x = coordinates[0]; - rawScroll.y = coordinates[1]; - } - else if (helper.type(coordinates) === TYPES.s || helper.type(coordinates) === TYPES.n) { - rawScroll.x = coordinates; - rawScroll.y = coordinates; - } - else if (helper.type(coordinates) === TYPES.o) { - coordinates = helper.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.length; 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 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 && !_normalizeRTLCache; - - if (helper.type(rawScroll) === TYPES.s) { - //check operator - if (rawScroll.length > 2) { - var possibleOperator = rawScroll.substr(0, 2); - for (i = 0; i < coordinatesOperators.length; i++) { - if (possibleOperator === coordinatesOperators[i]) { - operator = coordinatesOperators[i]; - break; - } - } - } - - //calculate units and shortcuts - rawScroll = operator !== undefined ? rawScroll.substr(2) : rawScroll; - rawScroll = rawScroll.replace(/min/g, 0); //'min' = 0% - rawScroll = rawScroll.replace(//g, (normalizeShortcuts ? '-' : _strEmpty) + _strHundredPercent); //'>' = 100% - rawScroll = rawScroll.replace(/px/g, _strEmpty); - rawScroll = rawScroll.replace(/%/g, mult + (maxScroll * (isRTLisX && _rtlScrollBehavior.n ? -1 : 1) / 100.0)); - rawScroll = rawScroll.replace(/vw/g, mult + _viewportSize.w); - rawScroll = rawScroll.replace(/vh/g, mult + _viewportSize.h); - amount = parseIntToZeroOrNumber(window.parseFloat(window.eval(rawScroll)).toFixed()); - } - else if (helper.type(rawScroll) === TYPES.n) { - amount = rawScroll; - } - - if (!isNaN(amount) && amount !== undefined && helper.type(amount) === TYPES.n) { - var normalizeIsRTLisX = _normalizeRTLCache && 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; - } - if (invert) - finalValue = maxScroll - finalValue; - if (negate) - finalValue *= -1; - - if (isRTLisX && _rtlScrollBehavior.n) { - finalValue = Math.max(maxScroll, finalValue); - finalValue = Math.min(0, finalValue); - } - else { - finalValue = Math.min(maxScroll, finalValue); - finalValue = Math.max(0, finalValue); - } - if (finalValue === currScroll) - finalValue = undefined; - } - return finalValue; - }; - - if (possibleElementIsJQuery || possibleElementIsHTMLElement) { - var finalElement = possibleElementIsJQuery ? possibleElement : helper(possibleElement); - if (finalElement.length === 0) - return; - - //get settings - if (coordinatesIsElementObj) { - var valid; - var axis = coordinates.axis; - var block = coordinates.block; - var blockType = helper.type(block); - var blockLength; - var margin = coordinates.margin; - var marginType = helper.type(margin); - var marginLength; - - //block can be [ string, or array of two strings ] - if (blockType === TYPES.s) - block = [block, block]; - else if (blockType === TYPES.a) { - blockLength = block.length; - if (blockLength > 2 || blockLength < 1) - block = undefined; - else { - valid = true; - if (blockLength === 1) - block[1] = strBegin; - for (i = 0; i < blockLength; i++) { - var item = block[i]; - if (helper.type(item) !== TYPES.s || !checkSettingsStringValue(item, elementObjSettingsBlockValues)) { - valid = false; - break; - } - } - if (!valid) - block = undefined; - } - } - else - block = undefined; - - //margin can be [ true, false, number, array of 2 numbers, array of 4 numbers ] - if (marginType === TYPES.n) - margin = [margin, margin, margin, margin]; - else if (marginType === 'boolean') { - if (margin) { - margin = [ - parseIntToZeroOrNumber(finalElement.css(_strMarginMinus + _strTop)), - parseIntToZeroOrNumber(finalElement.css(_strMarginMinus + _strRight)), - parseIntToZeroOrNumber(finalElement.css(_strMarginMinus + _strBottom)), - parseIntToZeroOrNumber(finalElement.css(_strMarginMinus + _strLeft)) - ]; - } - else - margin = [0, 0, 0, 0]; - } - else if (marginType === TYPES.a) { - marginLength = margin.length; - if (marginLength !== 2 && marginLength !== 4) - margin = undefined; - else { - valid = true; - for (i = 0; i < marginLength; i++) { - if (helper.type(margin[i]) !== TYPES.n) { - valid = false; - break; - } - } - if (valid) { - if (marginLength === 2) - margin = [margin[0], margin[1], margin[0], margin[1]]; - } - else - margin = undefined; - } - } - else - margin = undefined; - - elementObjSettings.axis = checkSettingsStringValue(axis, elementObjSettingsAxisValues) ? axis : elementObjSettings.axis; - elementObjSettings.block = block || elementObjSettings.block; - elementObjSettings.margin = margin || elementObjSettings.margin; - } - - //get coordinates - var elementOffset = finalElement.offset(); - var viewportOffset = _paddingElement.offset(); // use padding element instead of viewport element because padding element has never padding, margin or position applied. - var viewportScroll = { - l: _scrollHorizontalInfo.cs, - t: _scrollVerticalInfo.cs - }; - var settingsAxis = elementObjSettings.axis; - var settingsBlock = elementObjSettings.block; - var settingsMargin = elementObjSettings.margin; - var blockIsEnd = { - x : settingsBlock[0] === (_isRTL ? strBegin : strEnd), - y : settingsBlock[1] === strEnd - }; - var blockIsCenter = { - x : settingsBlock[0] === strCenter, - y : settingsBlock[1] === strCenter - }; - var blockIsNearest = { - x : settingsBlock[0] === strNearest, - y : settingsBlock[1] === strNearest - }; - var doNothing = { }; - var measuringForBlockIsRequired = blockIsEnd.x || blockIsEnd.y || blockIsCenter.x || blockIsCenter.y || blockIsNearest.x || blockIsNearest.y; - elementOffset.top -= settingsMargin[0]; - elementOffset.left -= settingsMargin[3]; - var elementScrollCoordinates = { - x: Math.round(elementOffset.left - viewportOffset.left + viewportScroll.l), - y: Math.round(elementOffset.top - viewportOffset.top + viewportScroll.t) - }; - if (_isRTL) { - if (!_rtlScrollBehavior.n && !_rtlScrollBehavior.i) - elementScrollCoordinates.x = Math.round(viewportOffset.left - elementOffset.left + viewportScroll.l); - if (_rtlScrollBehavior.n && _normalizeRTLCache) - elementScrollCoordinates.x *= -1; - if (_rtlScrollBehavior.i && _normalizeRTLCache) - elementScrollCoordinates.x = Math.round(viewportOffset.left - elementOffset.left + (_scrollHorizontalInfo.ms - viewportScroll.l)); - } - - if (measuringForBlockIsRequired) { - var rawElementSize = {}; - var rect; - if (_supportTransform) { - rect = finalElement[0].getBoundingClientRect(); - rawElementSize = { - w: rect[_strWidth], - h: rect[_strHeight] - }; - } - else { - rawElementSize = { - w: finalElement[0][WORDING.oW], - h: finalElement[0][WORDING.oH] - }; - } - var elementSize = { - w: rawElementSize.w + settingsMargin[3] + settingsMargin[1], - h: rawElementSize.h + settingsMargin[0] + settingsMargin[2] - }; - var finalizeBlock = function(isX) { - var scrollbarVars = getScrollbarVars(isX); - var divide = blockIsCenter[scrollbarVars.xy] ? 2 : 1; - var elementCenterOffset = elementOffset[scrollbarVars.lt] + (elementSize[scrollbarVars._wh] / 2); - var viewportCenterOffset = viewportOffset[scrollbarVars.lt] + (_viewportSize[scrollbarVars._wh] / 2); - - if(blockIsNearest[scrollbarVars.xy]) { - //if element is completely in view don't scroll on this axis - doNothing[scrollbarVars.xy] = elementSize[scrollbarVars._wh] <= _viewportSize[scrollbarVars._wh] && elementOffset[scrollbarVars.lt] >= viewportOffset[scrollbarVars.lt] && elementOffset[scrollbarVars.lt] + elementSize[scrollbarVars._wh] <= viewportOffset[scrollbarVars.lt] + _viewportSize[scrollbarVars._wh]; - blockIsEnd[scrollbarVars.xy] = elementSize[scrollbarVars._wh] < _viewportSize[scrollbarVars._wh] ? elementCenterOffset > viewportCenterOffset : elementCenterOffset < viewportCenterOffset; - } - - if (blockIsEnd[scrollbarVars.xy] || blockIsCenter[scrollbarVars.xy]) - elementScrollCoordinates[scrollbarVars.xy] -= ((_viewportSize[scrollbarVars._wh] / divide) - (elementSize[scrollbarVars._wh] / divide)) * (isX && _isRTL && _normalizeRTLCache ? -1 : 1); - }; - finalizeBlock(true); - finalizeBlock(false); - } - - if (settingsAxis === _strX || doNothing.y) - delete elementScrollCoordinates.y; - if (settingsAxis === _strY || doNothing.x) - delete elementScrollCoordinates.x; - - coordinates = elementScrollCoordinates; } - finalScroll.x = getFinalScroll(true, getRawScroll(coordinates).x); - finalScroll.y = getFinalScroll(false, getRawScroll(coordinates).y); - var scrollLeft = finalScroll.x !== undefined; - var scrollTop = finalScroll.y !== undefined; - - if (duration > 0 || durationIsObject) { - var animateObj = { }; - if (scrollLeft) - animateObj[_strScrollLeft] = finalScroll.x; - if (scrollTop) - animateObj[_strScrollTop] = finalScroll.y; - - if (durationIsObject) { - _viewportElement.animate(animateObj, duration); - } - else { - var animateOpt = { - duration : duration, - complete : complete - }; - if(helper.type(easing) === TYPES.a) { - var specialEasing = { }; - specialEasing[_strScrollLeft] = easing[0]; - specialEasing[_strScrollTop] = easing[1]; - animateOpt.specialEasing = specialEasing; - } - else { - animateOpt.easing = easing; - } - _viewportElement.animate(animateObj, animateOpt); - } + /** + * 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)); } - else { - if (scrollLeft) - _viewportElement[_strScrollLeft](finalScroll.x); - if (scrollTop) - _viewportElement[_strScrollTop](finalScroll.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]; } - }; - /** - * Stops all scroll animations. - */ - _base.scrollStop = function (param1, param2, param3) { - _viewportElement.stop(param1, param2, param3); - }; + /** + * 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 helper.prototype.find.call(el, selector).first(); + } - /** - * Returns all relevant elements. - * @returns {{target: *, host: *, padding: *, viewport: *, content: *, scrollbarHorizontal: {scrollbar: *, track: *, handle: *}, scrollbarVertical: {scrollbar: *, track: *, handle: *}, scrollbarCorner: *}} - */ - _base.getElements = function () { - return { - 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 - }; - }; + /** + * 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) + + '
'; + } - /** - * 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 (!helper.isPlainObject(obj)) - return obj; - var extended = helper.extend(true, {}, obj); - byPropertyPath.del(extended, 'c'); - var changePropertyName = function (from, to) { - if (extended.hasOwnProperty(from)) { - extended[to] = extended[from]; - delete extended[from]; - } - }; - changePropertyName('w', _strWidth); - changePropertyName('h', _strHeight); - 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) - }; - if (helper.type(stateProperty) === TYPES.s) - return byPropertyPath.get(obj, stateProperty); - return obj; - }; + /** + * 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; + } - /** - * Constructs the plugin. - * @param targetElement The element to which the plugin shall be applied. - * @param options The initial options of the plugin. - * @returns {boolean} True if the plugin was successfully initialized, false otherwise. - */ - function construct(targetElement, options) { - _defaultOptions = globals.defaultOptions; - _nativeScrollbarStyling = globals.nativeScrollbarStyling; - _nativeScrollbarSize = helper.extend(true, {}, globals.nativeScrollbarSize); - _nativeScrollbarIsOverlaid = helper.extend(true, {}, globals.nativeScrollbarIsOverlaid); - _overlayScrollbarDummySize = helper.extend(true, {}, globals.overlayScrollbarDummySize); - _rtlScrollBehavior = helper.extend(true, {}, globals.rtlScrollBehavior); + /** + * 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; + helper.extend(obj, extendObjRoot, true); + } - //parse & set options but don't update - setOptions(helper.extend(true, {}, _defaultOptions, options)); - var optionsCallbacks = _currentPreparedOptions.callbacks; + //==== Utils Cache ====// - //check if the plugin hasn't to be initialized - if (_nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.x && !_currentPreparedOptions.nativeScrollbarsOverlaid.initialize) { - var onInitializationWithdrawn = optionsCallbacks.onInitializationWithdrawn; - if (helper.isFunction(onInitializationWithdrawn)) - callCallback(onInitializationWithdrawn); + /** + * 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; } - _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 = helper(targetElement.ownerDocument); - _windowElement = helper(_documentElement[0].defaultView || _documentElement[0].parentWindow); - _htmlElement = _documentElement.find('html').first(); - _bodyElement = _htmlElement.find('body').first(); - _targetElement = helper(targetElement); - _isTextarea = _targetElement.is('textarea'); - _isBody = _targetElement.is('body'); - - 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]()); + /** + * 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; } - //build Hide-scrollbars DOM - if (_isTextarea) { - _targetElement.wrap(_strDivBegin + _classNameHostTextareaElement + _strDivEnd); - _targetElement.addClass(_classNameTextareaElement) - .addClass(_classNameTextInherit); - _hostElement = _targetElement.parent(); + /** + * 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; + } - var hostElementCSS = {}; - if (!_currentPreparedOptions.sizeAutoCapable) { - hostElementCSS[_strWidth] = _targetElement.css(_strWidth); - hostElementCSS[_strHeight] = _targetElement.css(_strHeight); + + //==== Shortcuts ====// + + /** + * jQuery type method shortcut. + */ + function type(obj) { + return helper.type(obj); + } + + /** + * jQuery extend method shortcut. + */ + function extend() { + return helper.extend.apply(this, arguments); + } + + /** + * jQuery addClass method shortcut. + */ + function addClass(el, classes) { + return helper.prototype.addClass.call(el, classes); + } + + /** + * jQuery removeClass method shortcut. + */ + function removeClass(el, classes) { + return helper.prototype.removeClass.call(el, classes); + } + + /** + * jQuery remove method shortcut. + */ + function remove(el) { + return helper.prototype.remove.call(el); + } + + + //==== 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" 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 isZoom = force === 'zoom'; + var imgElementSelector = 'img'; + var imgElementLoadEvent = 'load'; + if (force === _strAuto) { + attrsChanged = meaningfulAttrsChanged(); + contentSizeC = updateAutoContentSizeChanged(); + if (attrsChanged || contentSizeC) + update(false, contentSizeC); } - _hostElement.css(hostElementCSS) - .wrapInner(_strDivBegin + _classNameContentElement + _strSpace + _classNameTextInherit + _strDivEnd) - .wrapInner(_strDivBegin + _classNameViewportElement + _strSpace + _classNameTextInherit + _strDivEnd) - .wrapInner(_strDivBegin + _classNamePaddingElement + _strSpace + _classNameTextInherit + _strDivEnd); - _contentElement = _hostElement.find(_strDot + _classNameContentElement).first(); - _viewportElement = _hostElement.find(_strDot + _classNameViewportElement).first(); - _paddingElement = _hostElement.find(_strDot + _classNamePaddingElement).first(); - _textareaCoverElement = helper(_strDivBegin + _classNameTextareaCoverElement + _strDivEnd); - _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 if (isZoom) { + update(true, true); } else { - _targetElement.on(_strKeyDownEvent, textareaOnKeyDown) - .on(_strKeyUpEvent, textareaOnKeyUp); + force = _isSleeping || force; + _isSleeping = false; + update(false, false, force); } - } else { - _targetElement.addClass(_classNameHostElement); - _hostElement = _targetElement; - _hostElement.wrapInner(_strDivBegin + _classNameContentElement + _strDivEnd) - .wrapInner(_strDivBegin + _classNameViewportElement + _strDivEnd) - .wrapInner(_strDivBegin + _classNamePaddingElement + _strDivEnd); - _contentElement = _hostElement.find(_strDot + _classNameContentElement).first(); - _viewportElement = _hostElement.find(_strDot + _classNameViewportElement).first(); - _paddingElement = _hostElement.find(_strDot + _classNamePaddingElement).first(); - - //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) { - if (_nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.y) - _viewportElement.addClass(_classNameViewportNativeScrollbarsOverlaid); - else - _viewportElement.addClass(_classNameViewportNativeScrollbarsInvisible); - } - - //build mutation observers - if (_supportMutationObserver) { - var mutationObserver = compatibility.mO(); - var contentLastUpdate = compatibility.now(); - var contentTimeout; - - _mutationObserverHost = new mutationObserver(function (mutations) { - if (!_initialized || _isSleeping) - return; - var doUpdate = false; - helper.each(mutations, function () { - var t = this; - var target = this.target; - var attrName = t.attributeName; - - if (attrName === WORDING.c) - doUpdate = hostClassNamesChanged(t.oldValue, target.className); - else if (attrName === WORDING.s) - doUpdate = t.oldValue !== target.style.cssText; - else - doUpdate = true; - - if (doUpdate) - return false; - }); - if (doUpdate) - _base.update(_strAuto); - }); - _mutationObserverContent = new mutationObserver(function (mutations) { - if (!_initialized || _isSleeping) - return; - - var doUpdate = false; - for (var i = 0; i < mutations.length; i++) { - var mutation = mutations[i]; - if (isUnknownMutation(mutation)) { - doUpdate = true; - break; + if(!_isTextarea && !isZoom) { + _contentElement.find(imgElementSelector).each(function(i, el) { + var index = helper.inArray(el, _imgs); + if (index === -1) { + el = helper(el); + el.off(imgElementLoadEvent, imgOnLoad).on(imgElementLoadEvent, imgOnLoad); } - } - - if (doUpdate) { - var now = compatibility.now(); - var sizeAuto = (_heightAutoCache || _widthAutoCache); - var action = function () { - contentLastUpdate = now; - //if cols, rows or wrap attr was changed - if (_isTextarea) - textareaUpdate(); - - if (sizeAuto) - _base.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) { - _htmlElement.addClass(_classNameHTMLElement); - - //apply the body scroll to handle it right in the update method - _viewportElement[_strScrollLeft](initBodyScroll.l); - _viewportElement[_strScrollTop](initBodyScroll.t); - } - _sizeObserverElement = helper(_strDivBegin + 'os-resize-observer-host' + _strDivEnd); - _hostElement.prepend(_sizeObserverElement); - addResizeObserver(_sizeObserverElement, onHostResized); - - //update for the first time - onHostResized(); //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) - _hostElement.addClass(_classNameHostTransition); - }, 333); - - //the plugin is initialized now! - _initialized = true; - var onInitialized = optionsCallbacks.onInitialized; - if (helper.isFunction(onInitialized)) { - callCallback(onInitialized); - } - return _initialized; - }; - - if (construct(pluginTargetElement, options)) { - instances.add(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. - * @returns {*} - */ - window[PLUGINNAME] = function(pluginTargetElements, options) { - if(arguments.length === 0) - return this; - - initOverlayScrollbarsStatics(); - - var arr = [ ]; - var inst; - if(helper.isPlainObject(options)) { - if (pluginTargetElements && pluginTargetElements.length) { - if(pluginTargetElements.length > 1) { - helper.each(pluginTargetElements, function () { - inst = this; - if(inst !== undefined) - arr.push(OverlayScrollbarsInstance(inst, options, _pluginGlobals, _pluginAutoUpdateLoop)); }); - return arr; } - else - return OverlayScrollbarsInstance(pluginTargetElements[0], options, _pluginGlobals, _pluginAutoUpdateLoop) - } - else - return OverlayScrollbarsInstance(pluginTargetElements, options, _pluginGlobals, _pluginAutoUpdateLoop); - } - else { - if(pluginTargetElements) { - if(pluginTargetElements.length && pluginTargetElements.length > 0) { - if(pluginTargetElements.length > 1) { - helper.each(pluginTargetElements, function() { - inst = instances.get(this); - if(options === '!') { - if(inst !== undefined) - arr.push(inst); - } - else - arr.push(inst); - }); - return arr; + }; + + /** + 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 (helper.isEmptyObject(newOptions) || !helper.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 instances.get(pluginTargetElements[0]); + 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); + + 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++) + helper(_imgs[i]).off('load', imgOnLoad); + _imgs = undefined; + + instances.rem(pluginTargetElement); + callCallback(_currentPreparedOptions.callbacks.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 defined, else this object isn't valid. + * axis : [string], Default value is 'xy'. + * block : [string], Default value is 'begin'. + * margin : [number, array, boolean] Default value is false. + * } + * + * Possible axis settings are: + * 'x' Scrolls only the x axis. + * 'y' Scrolls only the y axis. + * 'xy' Scrolls both axis. + * 'yx' Same as 'xy' + * + * 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 edges. + * [ string, string ] Specify Begin or End for each axis individually. + * + * Possible margin settings are: -- The actual margin of the element wont be affect, this option affects only the final scroll offset. + * true The true margin of the element will be used. + * false No margin will be used. + * [NUMBER] The margin will be used for all edges. + * [ [NUMBER], [NUMBER] ] The first margin number will be used for the margin of the X axis egdes (left and right) and the second number will be used for the Y axis edges (top and bottom). + * [ [NUMBER], [NUMBER],[NUMBER], [NUMBER] ] Each edge gets its own margin value, the first value stays for the top margin, the second for the right margin, the third for the bottom margin and the forth for the left margin. + * + * @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 coordinatesXAxisProps = [_strX, _strLeft, 'l']; + var coordinatesYAxisProps = [_strY, _strTop, 't']; + var coordinatesOperators = ['+=', '-=', '*=', '/=']; + var i; + var finalScroll = { }; + var durationIsObject = type(duration) === TYPES.o; + var strEnd = 'end'; + var strBegin = 'begin'; + var strCenter = 'center'; + var strNearest = 'nearest'; + var elementObjSettings = { + axis: 'xy', + block: [strBegin, strBegin], + margin: [0, 0, 0, 0] + }; + var elementObjSettingsAxisValues = [_strX, _strY, 'xy', 'yx']; + var elementObjSettingsBlockValues = [strBegin, strEnd, strCenter, strNearest]; + var coordinatesIsElementObj = coordinates.hasOwnProperty('el'); + var possibleElement = coordinatesIsElementObj ? coordinates.el : coordinates; + var possibleElementIsJQuery = possibleElement instanceof helper || possibleElement instanceof window.jQuery; + var possibleElementIsHTMLElement = possibleElementIsJQuery ? false : isHTMLElement(possibleElement); + var checkSettingsStringValue = function (currValue, allowedValues) { + for (i = 0; i < allowedValues.length; i++) { + if (currValue === allowedValues[i]) + return true; + } + return false; + }; + var getRawScroll = function (coordinates) { + var rawScroll = {}; + if (type(coordinates) === TYPES.a && coordinates.length > 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) { + 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.length; 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 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 && !_normalizeRTLCache; + var strReplace = 'replace'; + if (type(rawScroll) === TYPES.s) { + //check operator + if (rawScroll.length > 2) { + var possibleOperator = rawScroll.substr(0, 2); + for (i = 0; i < coordinatesOperators.length; 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 = parseIntToZeroOrNumber(window.parseFloat(window.eval(rawScroll)).toFixed()); + } + else if (type(rawScroll) === TYPES.n) { + amount = rawScroll; + } + + if (!isNaN(amount) && amount !== undefined && type(amount) === TYPES.n) { + var normalizeIsRTLisX = _normalizeRTLCache && 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; + } + if (invert) + finalValue = maxScroll - finalValue; + if (negate) + finalValue *= -1; + + if (isRTLisX && _rtlScrollBehavior.n) { + finalValue = Math.max(maxScroll, finalValue); + finalValue = Math.min(0, finalValue); + } + else { + finalValue = Math.min(maxScroll, finalValue); + finalValue = Math.max(0, finalValue); + } + if (finalValue === currScroll) + finalValue = undefined; + } + return finalValue; + }; + + if (possibleElementIsJQuery || possibleElementIsHTMLElement) { + var finalElement = possibleElementIsJQuery ? possibleElement : helper(possibleElement); + if (finalElement.length === 0) + return; + + //get settings + if (coordinatesIsElementObj) { + var valid; + var axis = coordinates.axis; + var block = coordinates.block; + var blockType = type(block); + var blockLength; + var margin = coordinates.margin; + var marginType = type(margin); + var marginLength; + + //block can be [ string, or array of two strings ] + if (blockType === TYPES.s) + block = [block, block]; + else if (blockType === TYPES.a) { + blockLength = block.length; + if (blockLength > 2 || blockLength < 1) + block = undefined; + else { + valid = true; + if (blockLength === 1) + block[1] = strBegin; + for (i = 0; i < blockLength; i++) { + var item = block[i]; + if (type(item) !== TYPES.s || !checkSettingsStringValue(item, elementObjSettingsBlockValues)) { + valid = false; + break; + } + } + if (!valid) + block = undefined; + } + } + else + block = undefined; + + //margin can be [ true, false, number, array of 2 numbers, array of 4 numbers ] + if (marginType === TYPES.n) + margin = [margin, margin, margin, margin]; + else if (marginType === TYPES.b) { + if (margin) { + margin = [ + parseIntToZeroOrNumber(finalElement.css(_strMarginMinus + _strTop)), + parseIntToZeroOrNumber(finalElement.css(_strMarginMinus + _strRight)), + parseIntToZeroOrNumber(finalElement.css(_strMarginMinus + _strBottom)), + parseIntToZeroOrNumber(finalElement.css(_strMarginMinus + _strLeft)) + ]; + } + else + margin = [0, 0, 0, 0]; + } + else if (marginType === TYPES.a) { + marginLength = margin.length; + if (marginLength !== 2 && marginLength !== 4) + margin = undefined; + else { + valid = true; + for (i = 0; i < marginLength; i++) { + if (type(margin[i]) !== TYPES.n) { + valid = false; + break; + } + } + if (valid) { + if (marginLength === 2) + margin = [margin[0], margin[1], margin[0], margin[1]]; + } + else + margin = undefined; + } + } + else + margin = undefined; + + elementObjSettings.axis = checkSettingsStringValue(axis, elementObjSettingsAxisValues) ? axis : elementObjSettings.axis; + elementObjSettings.block = block || elementObjSettings.block; + elementObjSettings.margin = margin || elementObjSettings.margin; + } + + //get coordinates + var elementOffset = finalElement.offset(); + var viewportOffset = _paddingElement.offset(); // use padding element instead of viewport element because padding element has never padding, margin or position applied. + var viewportScroll = { + l: _scrollHorizontalInfo.cs, + t: _scrollVerticalInfo.cs + }; + var settingsAxis = elementObjSettings.axis; + var settingsBlock = elementObjSettings.block; + var settingsMargin = elementObjSettings.margin; + var blockIsEnd = { + x : settingsBlock[0] === (_isRTL ? strBegin : strEnd), + y : settingsBlock[1] === strEnd + }; + var blockIsCenter = { + x : settingsBlock[0] === strCenter, + y : settingsBlock[1] === strCenter + }; + var blockIsNearest = { + x : settingsBlock[0] === strNearest, + y : settingsBlock[1] === strNearest + }; + var doNothing = { }; + var measuringForBlockIsRequired = blockIsEnd.x || blockIsEnd.y || blockIsCenter.x || blockIsCenter.y || blockIsNearest.x || blockIsNearest.y; + elementOffset.top -= settingsMargin[0]; + elementOffset.left -= settingsMargin[3]; + var elementScrollCoordinates = { + x: Math.round(elementOffset.left - viewportOffset.left + viewportScroll.l), + y: Math.round(elementOffset.top - viewportOffset.top + viewportScroll.t) + }; + if (_isRTL) { + if (!_rtlScrollBehavior.n && !_rtlScrollBehavior.i) + elementScrollCoordinates.x = Math.round(viewportOffset.left - elementOffset.left + viewportScroll.l); + if (_rtlScrollBehavior.n && _normalizeRTLCache) + elementScrollCoordinates.x *= -1; + if (_rtlScrollBehavior.i && _normalizeRTLCache) + elementScrollCoordinates.x = Math.round(viewportOffset.left - elementOffset.left + (_scrollHorizontalInfo.ms - viewportScroll.l)); + } + + if (measuringForBlockIsRequired) { + var rawElementSize = {}; + var rect; + if (_supportTransform) { + rect = finalElement[0].getBoundingClientRect(); + rawElementSize = { + w: rect[_strWidth], + h: rect[_strHeight] + }; + } + else { + rawElementSize = { + w: finalElement[0][LEXICON.oW], + h: finalElement[0][LEXICON.oH] + }; + } + var elementSize = { + w: rawElementSize.w + settingsMargin[3] + settingsMargin[1], + h: rawElementSize.h + settingsMargin[0] + settingsMargin[2] + }; + var finalizeBlock = function(isX) { + var scrollbarVars = getScrollbarVars(isX); + var divide = blockIsCenter[scrollbarVars.xy] ? 2 : 1; + var elementCenterOffset = elementOffset[scrollbarVars.lt] + (elementSize[scrollbarVars._wh] / 2); + var viewportCenterOffset = viewportOffset[scrollbarVars.lt] + (_viewportSize[scrollbarVars._wh] / 2); + + if(blockIsNearest[scrollbarVars.xy]) { + //if element is completely in view don't scroll on this axis + doNothing[scrollbarVars.xy] = elementSize[scrollbarVars._wh] <= _viewportSize[scrollbarVars._wh] && elementOffset[scrollbarVars.lt] >= viewportOffset[scrollbarVars.lt] && elementOffset[scrollbarVars.lt] + elementSize[scrollbarVars._wh] <= viewportOffset[scrollbarVars.lt] + _viewportSize[scrollbarVars._wh]; + blockIsEnd[scrollbarVars.xy] = elementSize[scrollbarVars._wh] < _viewportSize[scrollbarVars._wh] ? elementCenterOffset > viewportCenterOffset : elementCenterOffset < viewportCenterOffset; + } + + if (blockIsEnd[scrollbarVars.xy] || blockIsCenter[scrollbarVars.xy]) + elementScrollCoordinates[scrollbarVars.xy] -= ((_viewportSize[scrollbarVars._wh] / divide) - (elementSize[scrollbarVars._wh] / divide)) * (isX && _isRTL && _normalizeRTLCache ? -1 : 1); + }; + finalizeBlock(true); + finalizeBlock(false); + } + + if (settingsAxis === _strX || doNothing.y) + delete elementScrollCoordinates.y; + if (settingsAxis === _strY || doNothing.x) + delete elementScrollCoordinates.x; + + coordinates = elementScrollCoordinates; + } + + finalScroll.x = getFinalScroll(true, getRawScroll(coordinates).x); + finalScroll.y = getFinalScroll(false, getRawScroll(coordinates).y); + var scrollLeft = finalScroll.x !== undefined; + var scrollTop = finalScroll.y !== undefined; + + if (duration > 0 || durationIsObject) { + var animateObj = { }; + if (scrollLeft) + animateObj[_strScrollLeft] = finalScroll.x; + if (scrollTop) + animateObj[_strScrollTop] = finalScroll.y; + + if (durationIsObject) { + _viewportElement.animate(animateObj, duration); + } + else { + var animateOpt = { + duration : duration, + complete : complete + }; + if(type(easing) === TYPES.a) { + var specialEasing = { }; + specialEasing[_strScrollLeft] = easing[0]; + specialEasing[_strScrollTop] = easing[1]; + animateOpt.specialEasing = specialEasing; + } + else { + animateOpt.easing = easing; + } + _viewportElement.animate(animateObj, animateOpt); + } + } + else { + if (scrollLeft) + _viewportElement[_strScrollLeft](finalScroll.x); + if (scrollTop) + _viewportElement[_strScrollTop](finalScroll.y); + } + }; + + /** + * Stops all scroll animations. + */ + _base.scrollStop = function (param1, param2, param3) { + _viewportElement.stop(param1, param2, param3); + }; + + /** + * Returns all relevant elements. + * @returns {{target: *, host: *, padding: *, viewport: *, content: *, scrollbarHorizontal: {scrollbar: *, track: *, handle: *}, scrollbarVertical: {scrollbar: *, track: *, handle: *}, scrollbarCorner: *}} + */ + _base.getElements = function () { + return { + 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 + }; + }; + + /** + * 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 (!helper.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) + }; + if (type(stateProperty) === TYPES.s) + return getObjectPropVal(obj, stateProperty); + return obj; + }; + + /** + * Constructs the plugin. + * @param targetElement The element to which the plugin shall be applied. + * @param options The initial options of the plugin. + * @returns {boolean} True if the plugin was successfully initialized, false otherwise. + */ + function construct(targetElement, options) { + _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)); + + var optionsCallbacks = _currentPreparedOptions.callbacks; + + //check if the plugin hasn't to be initialized + if (_nativeScrollbarIsOverlaid.x && _nativeScrollbarIsOverlaid.x && !_currentPreparedOptions.nativeScrollbarsOverlaid.initialize) { + callCallback(optionsCallbacks.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 = helper(targetElement.ownerDocument); + _windowElement = helper(_documentElement[0].defaultView || _documentElement[0].parentWindow); + _htmlElement = findFirst(_documentElement, 'html'); + _bodyElement = findFirst(_htmlElement, 'body'); + _targetElement = helper(targetElement); + _isTextarea = _targetElement.is('textarea'); + _isBody = _targetElement.is('body'); + + 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 = helper(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 mutation; + helper.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.style.cssText; + else + doUpdate = true; + + if (doUpdate) + return false; + }); + + if (doUpdate) + _base.update(_strAuto); + }); + _mutationObserverContent = new mutationObserver(function (mutations) { + if (!_initialized || _isSleeping) + return; + + var doUpdate = false; + var mutation; + helper.each(mutations, function () { + mutation = this; + doUpdate = isUnknownMutation(mutation); + return !doUpdate; + }); + + if (doUpdate) { + now = compatibility.now(); + sizeAuto = (_heightAutoCache || _widthAutoCache); + action = function () { + contentLastUpdate = now; + + //if cols, rows or wrap attr was changed + if (_isTextarea) + textareaUpdate(); + + if (sizeAuto) + _base.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 = helper(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(optionsCallbacks.onInitialized); + return _initialized; + } + + if (construct(pluginTargetElement, options)) { + instances.add(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. + * @returns {*} + */ + window[PLUGINNAME] = function(pluginTargetElements, options) { + if(arguments.length === 0) + return this; + + initOverlayScrollbarsStatics(); + + var arr = [ ]; + var inst; + var result; + if(helper.isPlainObject(options)) { + if (pluginTargetElements && pluginTargetElements.length) { + helper.each(pluginTargetElements, function () { + inst = this; + console.log(inst); + if(inst !== undefined) + arr.push(OverlayScrollbarsInstance(inst, options, _pluginsGlobals, _pluginsAutoUpdateLoop)); + }); + result = arr.length > 1 ? arr : arr[0]; } else - return instances.get(pluginTargetElements); + result = OverlayScrollbarsInstance(pluginTargetElements, options, _pluginsGlobals, _pluginsAutoUpdateLoop); } - } - }; + else if(pluginTargetElements) { + if(pluginTargetElements.length && pluginTargetElements.length > 0) { + helper.each(pluginTargetElements, function() { + inst = instances.get(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.get(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 = helper.extend(true, { }, _pluginGlobals); - delete globals['msie']; - return globals; - }; + /** + * 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 = helper.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 = _pluginGlobals.defaultOptions; - if(newDefaultOptions === undefined) - return helper.extend(true, { }, currDefaultOptions); + /** + * 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 helper.extend(true, { }, currDefaultOptions); - //set the new default options - _pluginGlobals.defaultOptions = helper.extend(true, { }, currDefaultOptions , newDefaultOptions); - }; - })(COMPATIBILITY, INSTANCES, HELPER, BYPROPERTYPATH); + //set the new default options + _pluginsGlobals.defaultOptions = helper.extend(true, { }, currDefaultOptions , _pluginsOptions.v(newDefaultOptions, _pluginsOptions.t, true)); + }; - return window[PLUGINNAME]; -}))); + return window[PLUGINNAME]; + })(COMPATIBILITY, INSTANCES, FRAMEWORK); + + var jQuery = window.jQuery; + 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. + * @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) { + var _elements = this; + if(jQuery.isPlainObject(options)) { + jQuery.each(_elements, function() { PLUGIN(this, options); }); + return _elements; + } + else + return PLUGIN(_elements, options); + }; + } + + return PLUGIN; + } +)); diff --git a/js/jquery.overlayScrollbars.min.js b/js/jquery.overlayScrollbars.min.js index 038df08..7dd9f0a 100644 --- a/js/jquery.overlayScrollbars.min.js +++ b/js/jquery.overlayScrollbars.min.js @@ -2,12 +2,12 @@ * OverlayScrollbars * https://github.com/KingSora/OverlayScrollbars * - * Version: 1.4.1 - * + * Version: 1.4.2 + * * Copyright KingSora. * https://github.com/KingSora * * Released under the MIT license. - * Date: 22.03.2018 + * Date: 14.04.2018 */ -!function(e,t){"function"==typeof define&&define.amd?define(["jquery"],function(n){return t(e,e.document,undefined,n)}):"object"==typeof exports?module.exports=t(e,e.document,undefined,require("jquery")):t(e,e.document,undefined,e.jQuery)}("undefined"!=typeof window?window:this,function(e,t,n,r){"use-strict";var o="OverlayScrollbars",i={o:"object",f:"function",a:"array",s:"string",n:"number",u:"undefined"},a={c:"class",s:"style",i:"id",oH:"offsetHeight",cH:"clientHeight",sH:"scrollHeight",oW:"offsetWidth",cW:"clientWidth",sW:"scrollWidth"},s={wW:function(){return e.innerWidth||t.documentElement[a.cW]||t.body[a.cW]},wH:function(){return e.innerHeight||t.documentElement[a.cH]||t.body[a.cH]},mO:function(){return e.MutationObserver||e.WebKitMutationObserver||e.WebkitMutationObserver||e.MozMutationObserver||n},rO:function(){return e.ResizeObserver||e.WebKitResizeObserver||e.WebkitResizeObserver||e.MozResizeObserver||n},rAF:function(){return e.requestAnimationFrame||e.webkitRequestAnimationFrame||e.mozRequestAnimationFrame||e.oRequestAnimationFrame||e.msRequestAnimationFrame||function(t){return e.setTimeout(t,1e3/60)}},cAF:function(){return e.cancelAnimationFrame||e.webkitCancelAnimationFrame||e.mozCancelAnimationFrame||e.oCancelAnimationFrame||e.msCancelAnimationFrame||function(t){return e.clearTimeout(t)}},now:function(){return Date.now()||(new Date).getTime()},stpP:function(e){e.stopPropagation?e.stopPropagation():e.cancelBubble=!0},prvD:function(e){e.preventDefault?e.preventDefault():e.returnValue=!1},page:function(e){var r="page",o="client",i="X",a="Y",s=((e=e.originalEvent||e).target||e.srcElement||t).ownerDocument||t,l=s.documentElement,c=s.body;if(e.touches!==n){var f=e.touches[0];return{x:f[r+i],y:f[r+a]}}return!e[r+i]&&e[o+i]&&null!=e[o+i]?{x:e[o+i]+(l&&l.scrollLeft||c&&c.scrollLeft||0)-(l&&l.clientLeft||c&&c.clientLeft||0),y:e[o+a]+(l&&l.scrollTop||c&&c.scrollTop||0)-(l&&l.clientTop||c&&c.clientTop||0)}:{x:e[r+i],y:e[r+a]}},mBtn:function(e){return e.which||e.button===n?e.which:1&e.button?1:2&e.button?3:4&e.button?2:0},bind:function(e,t){if(typeof e!==i.f)throw"Can't bind function!";var n=Array.prototype.slice.call(arguments,2),r=function(){},o=function(){return e.apply(this instanceof r?this:t,n.concat(Array.prototype.slice.call(arguments)))};return e.prototype&&(r.prototype=e.prototype),o.prototype=new r,o}},l=function(t){return t.fn.overlayScrollbars=function(n){var r=this;return t.isPlainObject(n)?(t.each(r,function(){e[o](this,n)}),r):e[o](r,n)},t}(r),c=function(e){var t=[],r="__overlayScrollbars__";function o(e,n){e[r]=n,t.push(e)}function i(n){var o=e.inArray(n,t);o>-1&&(delete n[r],t.splice(o,1))}function a(e){return s(e)!==n}function s(e){for(var n=0;n
'),u=function(){s.append(f);var e,t="overflow",n="hidden",r=f[0],o=c(f.children("div").first());return 0===r[a.oH]&&f.hide().show(),e={x:r[a.oH]-r[a.cH],y:r[a.oW]-r[a.cW]},i.restrictedMeasuring=function(){f.css(t,n);var e={w:r[a.sW],h:r[a.sH]};f.css(t,"visible");var o={w:r[a.sW],h:r[a.sH]};return e.w-o.w!=0||e.h-o.h!=0}(),i.nativeScrollbarStyling=(f.addClass("os-viewport-native-scrollbars-invisible"),f.css(t,n).hide().css(t,"scroll").show(),r[a.oH]-r[a.cH]==0&&r[a.oW]-r[a.cW]==0),i.rtlScrollBehavior=function(){f.css({"overflow-y":n,direction:"rtl"}).scrollLeft(0);var e=f.offset(),t=o.offset();f.scrollLeft(999);var r=o.offset();return{i:e.left===t.left,n:t.left-r.left==0}}(),f.removeAttr(a.s).remove(),e}(),v={x:0===u.x,y:0===u.y};function d(e){var r=!1,o="Webkit Moz ms O".split(" "),i=t.createElement("div"),a=null;if(e=e.toLowerCase(),i.style[e]!==n&&(r=!0),!1===r){a=e.charAt(0).toUpperCase()+e.substr(1);for(var s=0;s0)return parseInt(t.substring(n+5,t.indexOf(".",n)),10);if(t.indexOf("Trident/")>0){var r=t.indexOf("rv:");return parseInt(t.substring(r+3,t.indexOf(".",r)),10)}var o=t.indexOf("Edge/");return o>0&&parseInt(t.substring(o+5,t.indexOf(".",o)),10)}(),i.cssCalc=function(){for(var e=t.createElement("div"),n=["calc","-webkit-calc","-moz-calc","-o-calc"],r=0;r0){var e=r.wW(),v=r.wH(),h=e-t,p=v-n;if(0===h&&0===p)return;var y=Math.round(e/(t/100)),m=Math.round(v/(n/100)),x=Math.abs(h),w=Math.abs(p),g=Math.abs(y),b=Math.abs(m),C=d(),S=x>2&&w>2,O=!u(g,b);if(!!(S&&O&&(C!==o&&o>0))){s.append(f);var z=f[0];i.nativeScrollbarSize={x:z[a.oH]-z[a.cH],y:z[a.oW]-z[a.cW]},f.remove(),c.each(l.all(),function(){l.has(this)&&l.get(this).update("zoom")})}t=e,n=v,o=C}})}function u(e,t){var n=Math.abs(e),r=Math.abs(t);return!(n===r||n+1===r||n-1===r)}function d(){var t=e.screen.deviceXDPI||0,n=e.screen.logicalXDPI||1;return e.devicePixelRatio||t/n}}()}function y(e){var t,o=this,i="autoUpdate",a=i+"Interval",s=[],l=[],f=!1,u=33,v=u,d=r.now(),h=function(){if(s.length>0&&f){t=r.rAF()(function(){h()});var e=r.now(),o=e-d;if(o>v){d=e-o%v;for(var c=u,p=0;pw&&(y.update("auto"),l[p]=new Date(g+=w)),c=Math.max(1,Math.min(c,w))}}v=c}}else v=u};o.add=function(t){-1===c.inArray(t,s)&&(s.push(t),l.push(r.now()),s.length>0&&!f&&(f=!0,e.autoUpdateLoop=f,h()))},o.remove=function(o){var i=c.inArray(o,s);i>-1&&(l.splice(i,1),s.splice(i,1),0===s.length&&f&&(f=!1,e.autoUpdateLoop=f,t!==n&&(r.cAF()(t),t=-1)))}}function m(t,u,v,d){if(ro(t)){if(l.has(t)){var h=l.get(t);return h.options(u),h}var p,y,m,x,w,g,b,C,S,O,z,H,W,M,k,T,A,E,L,F,D,R,I,P,_,N,U,j,B,V,q,X,Y,J,K,Q,G,Z,$,ee,te,ne,re,oe,ie,ae,se,le,ce,fe,ue,ve,de,he,pe,ye,me,xe,we,ge,be,Ce,Se,Oe,ze,He,We,Me,ke,Te,Ae,Ee,Le,Fe,De,Re,Ie,Pe,_e,Ne,Ue,je,Be,Ve,qe,Xe,Ye,Je,Ke,Qe,Ge,Ze,$e,et,tt,nt,rt,ot,it,at,st,lt,ct,ft,ut,vt,dt,ht,pt,yt,mt,xt,wt,gt,bt=new e[o],Ct=!1,St=!1,Ot=!1,zt=!1,Ht=!1,Wt={w:0,h:0},Mt={},kt={},Tt={},At=175,Et="-hidden",Lt="margin-",Ft="padding-",Dt="border-",Rt="top",It="right",Pt="bottom",_t="left",Nt="min-",Ut="max-",jt="width",Bt="height",Vt="float",qt="",Xt="auto",Yt="scroll",Jt="100%",Kt="x",Qt="y",Gt='
',$t=".",en=" ",tn="scrollbar",nn="-horizontal",rn="-vertical",on=Yt+"Left",an=Yt+"Top",sn="mousedown touchstart",ln="mouseup touchend",cn="mousemove touchmove",fn="mouseenter",un="mouseleave",vn="keydown",dn="keyup",hn="selectstart",pn="transitionend webkitTransitionEnd oTransitionEnd",yn="__overlayScrollbarsRO__",mn="os-",xn=mn+"html",wn=mn+"host",gn=wn+"-textarea",bn=wn+"-"+tn+nn+Et,Cn=wn+"-"+tn+rn+Et,Sn=wn+"-transition",On=wn+"-rtl",zn=wn+"-resize-disabled",Hn=wn+"-scrolling",Wn=wn+"-overflow",Mn=Wn+"-x",kn=Wn+"-y",Tn=mn+"textarea",An=Tn+"-cover",En=mn+"padding",Ln=mn+"viewport",Fn=Ln+"-native-scrollbars-invisible",Dn=Ln+"-native-scrollbars-overlaid",Rn=mn+"content",In=mn+"content-arrange",Pn=mn+"content-glue",_n=mn+"size-auto-observer",Nn=mn+"resize-observer",Un=mn+"resize-observer-item",jn=Un+"-final",Bn=mn+"text-inherit",Vn=mn+tn,qn=Vn+"-track",Xn=qn+"-off",Yn=Vn+"-handle",Jn=Yn+"-off",Kn=Vn+"-unusable",Qn=Vn+"-"+Xt+Et,Gn=Vn+"-corner",Zn=Gn+"-resize",$n=Zn+"-both",er=Zn+nn,tr=Zn+rn,nr=Vn+nn,rr=Vn+rn,or=mn+"dragging",ir=mn+"theme-none",ar={},sr=33,lr=[],cr=11,fr=[112,113,114,115,116,117,118,119,120,121,123,33,34,37,38,39,40,16,17,18,19,20,144],ur=[],vr={x:0,y:0},dr={w:0,h:0};if(bt.sleep=function(){I=!0},bt.update=function(e){var t,n,r="zoom"===e,o="img",i="load";e===Xt?(t=vo(),n=uo(),(t||n)&&mo(!1,n)):r?mo(!0,!0):(e=I||e,I=!1,mo(!1,!1,e)),Ot||r||ne.find(o).each(function(e,t){-1===c.inArray(t,lr)&&(t=c(t)).off(i,jr).on(i,jr)})},bt.options=function(e,t){if(c.isEmptyObject(e)||!c.isPlainObject(e)){if(c.type(e)===i.s){if(arguments.length>=2){var n={};return f.set(n,e,t,!0),fo(n),void mo()}return f.get(N,e)}return N}fo(e);var r=I||!1;I=!1,mo(),I=r},bt.destroy=function(){St=!0,d.remove(bt),Wr(),gr(G),Ht&&gr(Q),G.remove(),Z!==n&&Z.remove(),te!==n&&te.remove(),Ht&&Q.remove(),H?(yr(K,cn,eo),yr(K,fn,Zr),yr(K,un,$r)):K.off(cn,eo).off(fn,Zr).off(un,$r),ie.remove(),le.remove(),oe&&oe.remove(),mt||Tr(),ne.contents().unwrap().unwrap().unwrap(),zt&&X.removeClass(xn),Ot?(J.off(Yt,Nr).off("drop",Ir).off("focus",Pr).off("focusout",_r),m>9||!y?J.off("input",Fr):J.off(vn,Dr).off(dn,Rr),re.remove(),J.removeClass(Tn).removeClass(Bn).unwrap().removeAttr(a.s),K.remove()):(J.removeClass(wn),K.removeClass(wn).removeClass(zn).removeClass(On).removeClass(bn).removeClass(Cn).removeClass(Sn).removeClass(Hn).removeClass(Wn).removeClass(Mn).removeClass(kn).removeClass(ir).removeClass(Qe));for(var e=0;e0)t.x=e[0],t.y=e[1];else if(c.type(e)===i.s||c.type(e)===i.n)t.x=e,t.y=e;else if(c.type(e)===i.o){for(var n in e=c.extend({},e),m=0,e)e.hasOwnProperty(n)&&(m>2&&delete e[n],m++);var r=function(t){var n=t?x:w;for(m=0;m2){var y=r.substr(0,2);for(m=0;m/g,(h?"-":qt)+Jt)).replace(/px/g,qt)).replace(/%/g,v+u*(d&&p.n?-1:1)/100)).replace(/vw/g,v+Tt.w)).replace(/vh/g,v+Tt.h),a=ho(e.parseFloat(e.eval(r)).toFixed())}else c.type(r)===i.n&&(a=r);if(!isNaN(a)&&a!==n&&c.type(a)===i.n){var x=Ke&&d,w=f*(x&&p.n?-1:1),b=x&&p.i,C=x&&p.n;switch(w=b?u-w:w,o){case"+=":s=w+a;break;case"-=":s=w-a;break;case"*=":s=w*a;break;case"/=":s=w/a;break;default:s=a}b&&(s=u-s),C&&(s*=-1),d&&p.n?(s=Math.max(u,s),s=Math.min(0,s)):(s=Math.min(u,s),s=Math.max(0,s)),s===f&&(s=n)}return s};if(L||F){var _=L?E:c(E);if(0===_.length)return;if(A){var N,U,j,B=t.axis,V=t.block,q=c.type(V),X=t.margin,Y=c.type(X);if(q===i.s)V=[V,V];else if(q===i.a)if((U=V.length)>2||U<1)V=n;else{for(N=!0,1===U&&(V[1]=O),m=0;m=Q[t.lt]&&K[t.lt]+ue[t._wh]<=Q[t.lt]+Tt[t._wh],re[t.xy]=ue[t._wh]o:r0||C){var pe={};if(de&&(pe[on]=b.x),he&&(pe[an]=b.y),C)ee.animate(pe,r);else{var ye={duration:r,complete:s};if(c.type(o)===i.a){var me={};me[on]=o[0],me[an]=o[1],ye.specialEasing=me}else ye.easing=o;ee.animate(pe,ye)}}else de&&ee[on](b.x),he&&ee[an](b.y)},bt.scrollStop=function(e,t,n){ee.stop(e,t,n)},bt.getElements=function(){return{target:J[0],host:K[0],padding:$[0],viewport:ee[0],content:ne[0],scrollbarHorizontal:{scrollbar:ie[0],track:ae[0],handle:se[0]},scrollbarVertical:{scrollbar:le[0],track:ce[0],handle:fe[0]},scrollbarCorner:oe}},bt.getState=function(e){var t=function(e){if(!c.isPlainObject(e))return e;var t=c.extend(!0,{},e);f.del(t,"c");var n=function(e,n){t.hasOwnProperty(e)&&(t[n]=t[e],delete t[e])};return n("w",jt),n("h",Bt),t},n={sleeping:t(I)||!1,autoUpdate:t(!rt),widthAuto:t(ye),heightAuto:t(me),padding:t(ge),overflowAmount:t(ke),hideOverflow:t(pe),hasOverflow:t(he),contentScrollSize:t(ve),viewportSize:t(Tt),hostSize:t(ue)};return c.type(e)===i.s?f.get(n,e):n},xo(t,u))return l.add(t,bt),bt;bt=n}function hr(){if(!I){var e=G[0],t={w:e[a.sW],h:e[a.sH]};if(Ct){var n=Cr(t,Be);Be=t,n&&mo(!0,!1)}else Be=t}}function pr(e,t,n){for(var r=t.split(en),o=0;o9||!y){var u='">',d="",h="childNodes",x=Gt+Nn+u;x+=Gt+Un+'" dir="ltr'+u,x+=Gt+Un+u,x+=Gt+jn+Zt,x+=d,x+=Gt+Un+u,x+=Gt+jn+'" style="width: 200%; height: 200%'+Zt,x+=d,x+=d,x+=d,e.prepend(x);var w,g,b,C,S=(e=e[0])[h][0][h][0],O=c(S[h][1]),z=c(S[h][0]),H=c(z[0][h][0]),M=S[a.oW],k=S[a.oH],T=2,A=v.nativeScrollbarSize,E=function(){z[on](n)[an](n),O[on](n)[an](n)},L=function(){g=0,w&&(M=b,k=C,o())},F=function(e){return b=S[a.oW],C=S[a.oH],w=b!=M||C!=k,e&&w&&!g?(r.cAF()(g),g=r.rAF()(L)):e||L(),E(),e&&(r.prvD(e),r.stpP(e)),!1},D={};D[Rt]=-(A.y+1)*T,D[It]=A.x*-T,D[Pt]=A.y*-T,D[_t]=-(A.x+1)*T,c(S).css(D),z.on(Yt,F),O.on(Yt,F),c(e).on(f,function(){F(!1)});var I={};I[jt]=n,I[Bt]=n,H.css(I),E()}else{var P=q[0],_=e;e=e[0];var N=P.attachEvent,U=typeof navigator===i.u||(navigator.userAgent.match(/Trident/)||navigator.userAgent.match(/Edge/));if(N)_.prepend(Gt+Nn+Zt),_.find($t+Nn).first()[0].attachEvent("onresize",o);else{var j=P.createElement(i.o);j.setAttribute("tabindex","-1"),j.setAttribute(a.c,Nn),j.onload=function(){var e=this.contentDocument.defaultView;e.addEventListener("resize",o),e.document.documentElement.style.display="none"},j.type="text/html",U&&_.prepend(j),j.data="about:blank",U||_.prepend(j),_.on(f,o)}}}if((e=c(e))[0]===G[0]){var B=function(){var t=K.css("direction");if(t!==Oe){var r={},o=0;return"ltr"===t?(r[_t]=0,r[It]=Xt,o=n):(r[_t]=Xt,r[It]=0,o=p.n?-n:p.i?0:n),G.children().first().css(r),e.scrollLeft(o),e.scrollTop(n),Oe=t,!0}return!1};B(),e.on(Yt,function(e){return B()&&mo(),r.prvD(e),r.stpP(e),!1})}}function gr(e){if(W){var t=e.contents()[0];t[yn].disconnect(),delete t[yn]}else e.children($t+Nn).first().remove()}function br(e,t,r){return!0===r?r:t===n||e!==t}function Cr(e,t,r,o,i){if(!0===i)return i;if(o===n&&i===n){if(!0===r)return r;r=n}return r=r===n?"w":r,o=o===n?"h":o,t===n||(e[r]!==t[r]||e[o]!==t[o])}function Sr(e,t){return t===n||(e.t!==t.t||e.r!==t.r||e.b!==t.b||e.l!==t.l)}function Or(e,t){Ct&&e.call(bt,t)}function zr(e,t,r){r===n&&(r=[qt,qt,qt,qt]),e[t+Rt]=r[0],e[t+It]=r[1],e[t+Pt]=r[2],e[t+_t]=r[3]}function Hr(){ot&&!rt&&(tt.observe(K[0],{attributes:!0,attributeOldValue:!0,attributeFilter:[a.i,a.c,a.s]}),nt.observe(Ot?J[0]:ne[0],{attributes:!0,attributeOldValue:!0,subtree:!Ot,childList:!Ot,characterData:!Ot,attributeFilter:Ot?["wrap","cols","rows"]:[a.i,a.c,a.s]}),rt=!0)}function Wr(){ot&&rt&&(tt.disconnect(),nt.disconnect(),rt=!1)}function Mr(e){if(!I){var t=(e.originalEvent||e).touches!==n;(1===r.mBtn(e)||t)&&(rt&&(yt=!0,Wr()),vr=r.page(e),dr.w=K[0][a.oW]-(k?0:T),dr.h=K[0][a.oH]-(k?0:A),q.on(hn,Ur).on(cn,kr).on(ln,Tr),Y.addClass(or),oe.setCapture&&oe.setCapture(),r.prvD(e),r.stpP(e))}}function kr(e){e.originalEvent;var t=r.page(e),n={};(wt||xt)&&(n[jt]=dr.w+t.x-vr.x),(gt||xt)&&(n[Bt]=dr.h+t.y-vr.y),K.css(n),r.stpP(e)}function Tr(e){var t=e!==n;q.off(hn,Ur).off(cn,kr).off(ln,Tr),Y.removeClass(or),oe.releaseCapture&&oe.releaseCapture(),t&&(yt&&Hr(),bt.update(Xt)),yt=!1}function Ar(){if(!I){var e=!Le,t=Tt.w-(k||ze||!ye?0:A+L),n=Tt.h-(k||ze||!me?0:A+L),r={},o=ye||e,i=J[0];r[Nt+jt]=qt,r[Nt+Bt]=qt,r[jt]=Xt,J.css(r);var s=i[a.oW],l=o?Math.max(s,i[a.sW]-1):1;l+=ye?F+(k?0:e?0:T+E):0,r[jt]=ye?l:Jt,r[Bt]=Xt,J.css(r);var c=i[a.oH],f=Math.max(c,i[a.sH]-1);return r[jt]=l,r[Bt]=f,re.css(r),r[Nt+jt]=t+(!k&&ye?T+E:0),r[Nt+Bt]=n+(!k&&me?A+L:0),J.css(r),{ow:s,oh:c,dw:l,dh:f}}}function Er(){var e=J.prop("selectionStart");if(e!==n){for(var t=J.val(),r=t.length,o=t.split("\n"),i=o.length,a=t.substr(0,e).split("\n"),s=0,l=0,c=a.length,f=a[a.length-1].length,u=0;ul&&(s=u+1,l=v)}return{cursorRow:c,cursorCol:f,rows:i,cols:l,wRow:s,pos:e,max:r}}}function Lr(e){for(var t=0;t-1&&ur.splice(n,1),0===ur.length&&(Ar(),bt.update(Xt),clearInterval(it))}}function Ir(){setTimeout(function(){Ar(),bt.update(Xt)},50)}function Pr(){at=!0}function _r(){at=!1,clearInterval(it),ur=[],Ar(),bt.update(Xt)}function Nr(e){return J[on](p.i&&Ke?9999999:0),J[an](0),r.prvD(e),r.stpP(e),!1}function Ur(e){return r.prvD(e),!1}function jr(){mo()}function Br(){return Te&&C.x&&C.y}function Vr(e,t,n){var r=e?bn:Cn,o=e?ie:le;t?K.removeClass(r):K.addClass(r),n?o.removeClass(Kn):o.addClass(Kn)}function qr(e,t){if(clearTimeout(st),e)ie.removeClass(Qn),le.removeClass(Qn);else{var n="active",r=function(){if(!pt){var e=se.hasClass(n)||fe.hasClass(n);!e&&(ut||vt||dt)&&ie.addClass(Qn),!e&&(ut||vt||dt)&&le.addClass(Qn)}};ct>0&&!0!==t?st=setTimeout(r,ct):r()}}function Xr(e){var t={},n=Gr(e),r=Math.min(1,(ue[n._wh]-(ze?e?T:A:0))/ve[n._wh]);t[n.wh]=Math.floor(100*r*1e5)/1e5+"%",Br()||n.h.css(t),n.i.hl=n.h[0]["offset"+n.WH],n.i.hlr=r}function Yr(e,t){var n=R&&e,r={},o=Gr(e),i=ee[0][Yt+o.WH]-ee[0]["client"+o.WH];p.n&&n&&(i*=-1);var a=t/i;a=isNaN(a)?0:Math.min(1,a),o.i.ms=i,o.i.cs=t,o.i.csr=a;var s=o.i.hl,l=o.t[0]["offset"+o.WH],c=(l-s)*a;if(c=isNaN(c)?0:c,n&&(p.n||!p.n&&!p.i)&&(c=l-s-c),c=Math.max(0,c),z){var f;n&&(c=-(l-s-c));var u="translate(",v="transform";f=e?u+c+"px, 0px)":u+"0px, "+c+"px)",r["-webkit-"+v]=f,r["-moz-"+v]=f,r["-ms-"+v]=f,r["-o-"+v]=f,r[v]=f}else r[o.lt]=c;Br()||o.h.css(r),o.i.ho=c,o.i.tl=l}function Jr(e,t){var n=t?"removeClass":"addClass",r=e?ce:fe,o=e?Xn:Jn;(e?ae:se)[n](o),r[n](o)}function Kr(){ie=c(Gt+Vn+en+nr+Zt),ae=c(Gt+qn+Zt),se=c(Gt+Yn+Zt),le=c(Gt+Vn+en+rr+Zt),ce=c(Gt+qn+Zt),fe=c(Gt+Yn+Zt),ie.append(ae),ae.append(se),le.append(ce),ce.append(fe),$.after(le),$.after(ie),O&&(ie.on(pn,function(e){e.target===ie[0]&&(Xr(!0),Yr(!0,ee[on]()))}),le.on(pn,function(e){e.target===le[0]&&(Xr(!1),Yr(!1,ee[an]()))})),Qr(!0),Qr(!1),oe=c(Gt+en+Gn+Zt),K.append(oe)}function Qr(e){var t,o,i,a=Gr(e),s=a.xy,l=Yt+a.LT,c="active",f=1,u=function(){f=.5},v=function(){f=1},d=function(n){n.originalEvent;var i=a.i.tl,c=a.i.hl,f=a.i.ms*((c/2+r.page(n)[s]-o-c/2)/(i-c));f=isFinite(f)?f:0,R&&e&&(p.n||!p.n&&!p.i)&&(f*=-1),ee[l](t+f),H||r.prvD(n)},h=function(e){e=e||e.originalEvent,Y.removeClass(or),a.h.removeClass(c),a.t.removeClass(c),a.s.removeClass(c),H?(yr(q,cn,d),yr(q,ln,h),yr(q,vn,y),yr(q,dn,m)):q.off(cn,d).off(ln,h).off(vn,y).off(dn,m),q.off(hn,Ur),v(),t=n,o=n,i!==n&&(bt.scrollStop(),clearTimeout(i),i=n);var r=K[0].getBoundingClientRect();e.clientX>=r.left&&e.clientX<=r.right&&e.clientY>=r.top&&e.clientY<=r.bottom||$r(),(ut||vt)&&qr(!1)},y=function(e){16==e.keyCode&&u()},m=function(e){16==e.keyCode&&v()};a.h.on(sn,function(i){if(!I){var f=(i.originalEvent||i).touches!==n;Br()||!Ye||f&&!ht||(1===r.mBtn(i)||f)&&(t=(t=ee[l]())===n?0:t,(R&&e&&!p.n||!R)&&(t=t<0?0:t),o=r.page(i)[s],Y.addClass(or),a.h.addClass(c),a.s.addClass(c),H?(pr(q,cn,d),pr(q,ln,h)):q.on(cn,d).on(ln,h),q.on(hn,Ur),r.prvD(i))}}),a.t.on(sn,function(t){if(!I){var l=(t.originalEvent||t).touches!==n;if(!Br()&&Xe&&(!l||ht)&&(1===r.mBtn(t)||l)){var v,d=Tt[a._wh],x=a.t.offset()[a.lt],w=!0;t.shiftKey&&u();var g=function(){var t=a.i.ho,r=a.i.hl,s=o-x,l=200*f,c=w?Math.max(333,l):l,u={},h=R&&e&&(!p.i&&!p.n||Ke),y=t>s;h&&(y=t=s;h&&(m=v?t+r>=s:t<=s),m?(clearTimeout(i),bt.scrollStop(),i=n):i=setTimeout(g,c),w=!1};o=r.page(t)[s],Y.addClass(or),a.t.addClass(c),a.s.addClass(c),H?(pr(q,ln,h),pr(q,vn,y),pr(q,dn,m)):q.on(ln,h).on(vn,y).on(dn,m),q.on(hn,Ur),g(),r.prvD(t)}}}).hover(function(){(ut||vt)&&(pt=!0,qr(!0))},function(){(ut||vt)&&(pt=!1,qr(!1))}),a.s.on(sn,function(e){r.stpP(e)})}function Gr(e){return{wh:e?jt:Bt,WH:e?"Width":"Height",lt:e?_t:Rt,LT:e?"Left":"Top",xy:e?Kt:Qt,XY:e?"X":"Y",_wh:e?"w":"h",_lt:e?"l":"t",t:e?ae:ce,h:e?se:fe,s:e?ie:le,i:e?Mt:kt}}function Zr(){dt&&qr(!0)}function $r(){dt&&!Y.hasClass(or)&&qr(!1)}function eo(){vt&&(qr(!0),clearTimeout(lt),lt=setTimeout(function(){vt&&qr(!1)},100))}function to(e){if(!I){var t=U.callbacks,r=t.onScrollStart,o=t.onScroll,i=t.onScrollStop;P!==n?clearTimeout(P):((ut||vt)&&qr(!0),Br()||K.addClass(Hn),c.isFunction(r)&&Or(r,e)),Yr(!0,ee[on]()),Yr(!1,ee[an]()),c.isFunction(o)&&Or(o,e),P=setTimeout(function(){no(e),c.isFunction(i)&&Or(i,e)},At)}}function no(){clearTimeout(P),P=n,(ut||vt)&&qr(!1),Br()||K.removeClass(Hn)}function ro(e){return typeof HTMLElement===i.o?e instanceof HTMLElement:e&&typeof e===i.o&&null!==e&&1===e.nodeType&&typeof e.nodeName===i.s}function oo(e,t,r,o){var a,s,l,u,v,d={n:t,s:!1,v:n,p:n},h=i.u,p=f.has(e,t),y=f.get(e,t),m=!1,x=!0!==p,w="*",g=!1;for(c.type(r)!==i.a&&(r=[r]),v=r.length,s=0;s1){var C=0;for(u=0;u1)break}1===C&&(g=!0)}else g=!0;b===n&&(m=!0)}if(x&&!1===p&&m&&(x=!1),!x){a=y,h=c.type(a);var O=function(e){var t=c.type(e);return t===h&&(t!==i.s||(!!g||a===e))&&(d.s=!0,d.v=a,d.p=a,!0)};for(s=0;s-1&&i.splice(f,1);for(var u=0;u0&&Ct&&i-j0?K.addClass(ce):K.addClass(ir)),it&&(!0===ot?(Wr(),d.add(bt)):null===ot&&y?(Wr(),d.add(bt)):(d.remove(bt),Hr())),Be)if(je)if(Z===n&&(Z=c(Gt+Pn+Zt),$.before(Z)),Ht)Q.show();else{Q=c(Gt+_n+Zt),Z.before(Q);var kt={w:-1,h:-1};wr(Q,function(){var e={w:Q[0][a.oW],h:Q[0][a.oH]};Cr(e,kt)&&(Ct&&me&&e.h>0||ye&&e.w>0?mo():(Ct&&!me&&0===e.h||!ye&&0===e.w)&&mo()),kt=e}),Ht=!0,null!==w&&Q.css(Bt,w+"(100% + 1px)")}else Ht&&Q.hide();o&&(G.find("*").trigger(Yt),Ht&&Q.find("*").trigger(Yt));var At,Et=K.css("direction"),$t=br(Et,Se,o),en=K.css("box-sizing"),tn=br(en,we,o),nn={c:o,t:ho(K.css(Ft+Rt)),r:ho(K.css(Ft+It)),b:ho(K.css(Ft+Pt)),l:ho(K.css(Ft+_t))};try{At=Ht?Q[0].getBoundingClientRect():null}catch(_o){return}k="border-box"===en;var rn=(R="rtl"===Et)?_t:It,ln=R?It:_t,vn=K[0],dn=$[0],hn=!1,pn=!(!Ht||"none"===K.css(Vt))&&(0===Math.round(At.right-At.left)&&(!!Pe||vn[a.cW]-T>0));if(je&&!pn){var yn=vn[a.oW],mn=Z.css(jt);Z.css(jt,Xt);var xn=vn[a.oW];Z.css(jt,mn),(hn=yn!==xn)||(Z.css(jt,yn+1),xn=vn[a.oW],Z.css(jt,mn),hn=yn!==xn)}var wn=(pn||hn)&&je,gn=br(wn,ye,o),bn=!wn&&ye,Cn=!!Ht&&0===Math.round(At.bottom-At.top),Sn=br(Cn,me,o),Tn=!Cn&&me,An="-"+jt,En=wn&&k||!k,Ln=Cn&&k||!k,Fn={c:o,t:Ln?ho(K.css(Dt+Rt+An)):0,r:En?ho(K.css(Dt+It+An)):0,b:Ln?ho(K.css(Dt+Pt+An)):0,l:En?ho(K.css(Dt+_t+An)):0},Dn={c:o,t:ho(K.css(Lt+Rt)),r:ho(K.css(Lt+It)),b:ho(K.css(Lt+Pt)),l:ho(K.css(Lt+_t))},Rn={h:String(K.css(Ut+Bt)),w:String(K.css(Ut+jt))},Nn={},Un={};if(T=nn.l+nn.r,A=nn.t+nn.b,nn.c=Sr(nn,ge),E=Fn.l+Fn.r,L=Fn.t+Fn.b,Fn.c=Sr(Fn,be),F=Dn.l+Dn.r,D=Dn.t+Dn.b,Dn.c=Sr(Dn,Ce),Rn.ih=ho(Rn.h),Rn.iw=ho(Rn.w),Rn.ch=Rn.h.indexOf("px")>-1,Rn.cw=Rn.w.indexOf("px")>-1,Rn.c=Cr(Rn,xe,o),Se=Et,we=en,ye=wn,me=Cn,ge=nn,be=Fn,Ce=Dn,xe=Rn,$t&&Ht&&Q.css(Vt,ln),nn.c||$t||_e||gn||Sn||tn||Be){var jn={},Bn={};zr(Un,Lt,[-nn.t,-nn.r,-nn.b,-nn.l]),Pe?(zr(jn,qt,[nn.t,nn.r,nn.b,nn.l]),zr(Ot?Bn:Nn,Ft)):(zr(jn,qt),zr(Ot?Bn:Nn,Ft,[nn.t,nn.r,nn.b,nn.l])),$.css(jn),J.css(Bn)}Tt={w:dn[a.oW],h:dn[a.oH]};var Vn=!!Ot&&Ar();if(Cn&&(Sn||_e||tn||Rn.c||nn.c||Fn.c)?(Rn.cw&&(Nn[Ut+Bt]=Rn.ch?Rn.ih-(Pe?A:0)+(k?-L:A):qt),Nn[Bt]=Xt):(Sn||_e)&&(Nn[Ut+Bt]=qt,Nn[Bt]=Jt),wn&&(gn||_e||tn||Rn.c||nn.c||Fn.c||$t)?(Rn.cw&&(Nn[Ut+jt]=Rn.cw?Rn.iw-(Pe?T:0)+(k?-E:T)+(C.y?S.y:0):qt),Nn[jt]=Xt,Un[Ut+jt]=Jt):(gn||_e)&&(Nn[Ut+jt]=qt,Nn[jt]=Jt,Nn[Vt]=qt,Un[Ut+jt]=qt),wn&&(Rn.cw||(Nn[Ut+jt]=qt),Un[jt]=Ot&&pt?Vn.dw:Xt,Nn[jt]=Xt,Nn[Vt]=ln),Cn&&(Rn.ch||(Nn[Ut+Bt]=qt),Un[Bt]=Ot?St?Vn.dh:Xt:ne[0][a.cH]),je&&Z.css(Un),ne.css(Nn),Nn={},Un={},he=he||{x:!1,y:!1},e||t||$t||tn||_e||gn||wn||Sn||Cn||Rn.c||nt||lt||Ue||De||q||yt||Mt||Ie||_e||yt||Mt||o){var qn="overflow",Xn=qn+"-x",Yn=qn+"-y",Jn="hidden",Kn="visible",Qn=M&&(C.x||C.y||Tt.w0&&(Un[jt]=Math.max(1,Un[jt]),Un[Bt]=Math.max(1,Un[Bt])),Ot&&re.css(kr),Z.css(Un)}wn&&(Nn[jt]=Jt),!wn||k||rt||(Nn[Vt]="none"),ne.css(Nn),Nn={};var Tr=or.getBoundingClientRect(),Lr={w:Math.max(or[a.sW],lr[a.sW]),h:Math.max(or[a.sH],lr[a.sH])};if(Qn&&ne.css(qn,qt),Tr.width!==n){var Fr=Tr.width,Dr=Tr.height,Rr=.001;Lr.w+=ho(Fr+Rr)-Fr,Lr.h+=ho(Dr+Rr)-Dr}Lr.c=t=Cr(Lr,ve,o),ve=Lr,e=Cr(vr={w:vn[a.cW],h:vn[a.cH]},ue),ue=vr,Tt={w:dn[a.oW],h:dn[a.oH]};var Ir={x:"v-s"===st.x,y:"v-s"===st.y},Pr={x:"v-h"===st.x,y:"v-h"===st.y},_r={x:"s"===st.x,y:"s"===st.y},Nr={x:Math.max(0,Math.round(100*(Lr.w-vr.w+(Pe?T:0)))/100),y:Math.max(0,Math.round(100*(Lr.h-vr.h+(Pe?A:0)))/100)},Ur=Ot&&(0===Tt.w||0===Tt.h);Ur&&(Nr.x=0,Nr.y=0);var jr={x:Nr.x>0,y:Nr.y>0},Br={x:jr.x,y:jr.y};(Ir.x||Pr.x)&&(Br.x=jr.y&&!Ir.y&&!Pr.y),(Ir.y||Pr.y)&&(Br.y=jr.x&&!Ir.x&&!Pr.x),Br.xs=!!Br.x&&(_r.x||Ir.x),Br.ys=!!Br.y&&(_r.y||Ir.y);var Kr={x:jr.x&&Br.xs,y:jr.y&&Br.ys},Qr=ke;if(Nr.c=Cr(Nr,ke,Kt,Qt,o),ke=Nr,jr.c=Cr(jr,he,Kt,Qt,o),he=jr,Br.c=Cr(Br,pe,Kt,Qt,o),pe=Br,C.x||C.y){var Gr=o,to={};if((jr.x||jr.y)&&(to.w=C.y&&jr.y?Lr.w+S.y:qt,to.h=C.x&&jr.x?Lr.h+S.x:qt,Gr=br(to,de,o),de=to),jr.c||Br.c||Lr.c||$t||gn||Sn||wn||Cn||nt){var no="px solid transparent";Nn[Dt+ln]=qt,Nn[Lt+ln]=qt,C.x&&jr.x&&Br.xs?(Cn&&(Nn[Lt+Pt]=tt?qt:S.x),Nn[Dt+Pt]=Cn||tt?qt:S.x+no):(to.h=qt,Gr=!0,Nn[Dt+Pt]=qt,Nn[Lt+Pt]=qt),C.y&&jr.y&&Br.ys?(wn&&(Nn[Lt+rn]=tt?qt:S.y),Nn[Dt+rn]=tt?qt:S.y+no):(to.w=qt,Gr=!0,Nn[Dt+rn]=qt,Nn[Lt+rn]=qt)}if(tt&&(to.w=qt,to.h=qt,Gr=!0),Gr){var ro={};ro[jt]=Br.y?to.w:qt,ro[Bt]=Br.x?to.h:qt,te===n&&(te=c(Gt+In+Zt),ee.prepend(te)),te.css(ro)}ne.css(Nn)}var oo={};jn={};if(e||jr.c||Br.c||Lr.c||lt||tn||nt||$t||Ue||Sn){oo[ln]=qt;var ao=function(){oo[Pt]=qt,Wt.h=0},so=function(){oo[rn]=qt,Wt.w=0};if(jr.x&&Br.xs?(oo[Xn]=Yt,tt?ao():(oo[Pt]=-(C.x?S.x:g.x),Wt.h=C.x?S.y:0)):(oo[Xn]=qt,ao()),jr.y&&Br.ys?(oo[Yn]=Yt,tt?so():(oo[rn]=-(C.y?S.y:g.y),Wt.w=C.y?S.x:0)):(oo[Yn]=qt,so()),(Tt.h-1,Po=Ro.y>-1;(Io||Po)&&(Po&&ee[an](Ro.y),Io&&(R&&Ke&&p.i?ee[on](0):ee[on](Ro.x)))}Fe=Wo}else Ot||(R&&p.i&&C.y&&jr.x&&Ke&&(f.l+=Wt.w),ee[on](f.l),ee[an](f.t));$t&&c.isFunction(P)&&Or(P,{isRTL:R,dir:Et}),e&&c.isFunction(N)&&Or(N,{width:ue.w,height:ue.h}),t&&c.isFunction(_)&&Or(_,{width:ve.w,height:ve.h}),(jr.c||Br.c)&&c.isFunction(z)&&Or(z,{x:jr.x,y:jr.y,xScrollable:Br.xs,yScrollable:Br.ys,clipped:Br.x||Br.y}),Nr.c&&c.isFunction(W)&&Or(W,{x:Nr.x,y:Nr.y})}zt&&(jr.c||et.c)&&(et.f||io(),C.y&&jr.x&&ne.css(Nt+jt,et.w+S.y),C.x&&jr.y&&ne.css(Nt+Bt,et.h+S.x),et.c=!1),xr(G),xr(Q),c.isFunction(O)&&Or(O,{forced:o})}}function xo(e,t){_=v.defaultOptions,x=v.nativeScrollbarStyling,g=c.extend(!0,{},v.nativeScrollbarSize),C=c.extend(!0,{},v.nativeScrollbarIsOverlaid),S=c.extend(!0,{},v.overlayScrollbarDummySize),p=c.extend(!0,{},v.rtlScrollBehavior),fo(c.extend(!0,{},_,t));var n,o=U.callbacks;if(C.x&&C.x&&!U.nativeScrollbarsOverlaid.initialize){var i=o.onInitializationWithdrawn;return c.isFunction(i)&&Or(i),!1}if(w=v.cssCalc,m=v.msie,y=v.autoUpdateRecommended,O=v.supportTransition,z=v.supportTransform,H=v.supportPassiveEvents,W=v.supportResizeObserver,ot=v.supportMutationObserver,M=v.restrictedMeasuring,q=c(e.ownerDocument),V=c(q[0].defaultView||q[0].parentWindow),X=q.find("html").first(),Y=X.find("body").first(),J=c(e),Ot=J.is("textarea"),(zt=J.is("body"))&&((n={}).l=Math.max(J[on](),X[on](),V[on]()),n.t=Math.max(J[an](),X[an](),V[an]())),Ot){J.wrap(Gt+gn+Zt),J.addClass(Tn).addClass(Bn),K=J.parent();var s={};U.sizeAutoCapable||(s[jt]=J.css(jt),s[Bt]=J.css(Bt)),K.css(s).wrapInner(Gt+Rn+en+Bn+Zt).wrapInner(Gt+Ln+en+Bn+Zt).wrapInner(Gt+En+en+Bn+Zt),ne=K.find($t+Rn).first(),ee=K.find($t+Ln).first(),$=K.find($t+En).first(),re=c(Gt+An+Zt),ne.prepend(re),J.on(Yt,Nr).on("drop",Ir).on("focus",Pr).on("focusout",_r),m>9||!y?J.on("input",Fr):J.on(vn,Dr).on(dn,Rr)}else J.addClass(wn),(K=J).wrapInner(Gt+Rn+Zt).wrapInner(Gt+Ln+Zt).wrapInner(Gt+En+Zt),ne=K.find($t+Rn).first(),ee=K.find($t+Ln).first(),$=K.find($t+En).first(),ne.on(pn,function(e){!0!==Ae&&po((e=e.originalEvent||e).propertyName)&&mo(Xt)});if(Kr(),H?pr(ee,Yt,to):ee.on(Yt,to),x&&(C.x&&C.y?ee.addClass(Dn):ee.addClass(Fn)),ot){var l,f=r.mO(),u=r.now();tt=new f(function(e){if(Ct&&!I){var t=!1;c.each(e,function(){var e=this,n=this.target,r=e.attributeName;if(t=r===a.c?lo(e.oldValue,n.className):r!==a.s||e.oldValue!==n.style.cssText)return!1}),t&&bt.update(Xt)}}),nt=new f(function(e){if(Ct&&!I){for(var t=!1,n=0;ncr||!i?a():l=setTimeout(a,cr)}}})}zt&&(X.addClass(xn),ee[on](n.l),ee[an](n.t)),G=c(Gt+"os-resize-observer-host"+Zt),K.prepend(G),wr(G,hr),hr(),bt.update(Xt),setTimeout(function(){O&&!St&&K.addClass(Sn)},333),Ct=!0;var d=o.onInitialized;return c.isFunction(d)&&Or(d),Ct}}e[o]=function(e,t){if(0===arguments.length)return this;h();var r,o=[];return c.isPlainObject(t)?e&&e.length?e.length>1?(c.each(e,function(){(r=this)!==n&&o.push(m(r,t,u,v))}),o):m(e[0],t,u,v):m(e,t,u,v):e?e.length&&e.length>0?e.length>1?(c.each(e,function(){r=l.get(this),"!"===t?r!==n&&o.push(r):o.push(r)}),o):l.get(e[0]):l.get(e):void 0},e[o].globals=function(){h();var e=c.extend(!0,{},u);return delete e.msie,e},e[o].defaultOptions=function(e){h();var t=u.defaultOptions;if(e===n)return c.extend(!0,{},t);u.defaultOptions=c.extend(!0,{},t,e)}}(s,c,l,f);return e[o]}); \ No newline at end of file +!function(t,e){"object"==typeof module&&"object"==typeof module.exports?module.exports=e(t,t.document,undefined,require("jquery")):e(t,t.document,undefined,t.jQuery)}("undefined"!=typeof window?window:this,function(t,e,n,r){"use strict";var o="OverlayScrollbars",i={o:"object",f:"function",a:"array",s:"string",b:"boolean",n:"number",u:"undefined",z:"null"},a={c:"class",s:"style",i:"id",oH:"offsetHeight",cH:"clientHeight",sH:"scrollHeight",oW:"offsetWidth",cW:"clientWidth",sW:"scrollWidth"},s=r,l=function(r,s,l){var c,u,f,h,d,v,p,y,x,w,m,b,g,S=(f=[i.b,i.n,i.s,i.a,i.o,i.f,i.z],h=" ",d=":",v=[i.z,i.s],p=i.b,y=i.n,x=[i.z,p],w=[i.z,i.f],b={className:["os-theme-dark",v],resize:["none","n:none b:both h:horizontal v:vertical"],sizeAutoCapable:[!0,p],clipAlways:[!0,p],normalizeRTL:[!0,p],paddingAbsolute:[!1,p],autoUpdate:[null,x],autoUpdateInterval:[33,y],nativeScrollbarsOverlaid:{showNativeScrollbars:[!1,p],initialize:[!0,p]},overflowBehavior:{x:["scroll",m="v-h:visible-hidden v-s:visible-scroll s:scroll h:hidden"],y:["scroll",m]},scrollbars:{visibility:["auto","v:visible h:hidden a:auto"],autoHide:["never","n:never s:scroll l:leave m:move"],autoHideDelay:[800,y],dragScrolling:[!0,p],clickScrolling:[!1,p],touchSupport:[!0,p]},textarea:{dynWidth:[!1,p],dynHeight:[!1,p]},callbacks:{onInitialized:[null,w],onInitializationWithdrawn:[null,w],onDestroyed:[null,w],onScrollStart:[null,w],onScroll:[null,w],onScrollStop:[null,w],onOverflowChanged:[null,w],onOverflowAmountChanged:[null,w],onDirectionChanged:[null,w],onContentSizeChanged:[null,w],onHostSizeChanged:[null,w],onUpdated:[null,w]}},{d:(g=function(t){var e=function(n){var r,o,a;for(r in n)n.hasOwnProperty(r)&&(o=n[r],(a=l.type(o))===i.a?n[r]=o[t?1:0]:a===i.o&&(n[r]=e(o)));return n};return e(l.extend(!0,{},b))})(),t:g(!0),v:function(t,e,n,r,o){var a={},s=l.extend(!0,{},t),c=function(t,e,o,a){for(var s in e)if(e.hasOwnProperty(s)&&t.hasOwnProperty(s)){var u,v,p,y,x,w,m,b,g=!1,S=e[s],z=l.type(S),O=l.type(S)!==i.a?[S]:S,C=t[s],M=l.type(C),H=a?a+".":"",W='The option "'+H+s+"\" wasn't set, because",k=[],A=[];if(z===i.o)o[s]={},c(C,S,o[s],H+s),l.isEmptyObject(C)&&delete t[s];else{for(w=0;w0?"\r\nValid strings are: [ "+A.join(", ").split(d).join(", ")+" ].":"")),delete t[s]}}};return c(s,e,a),o?l.extend(!0,a,s):!l.isEmptyObject(s)&&n&&console.warn("The following options are discarded due to invalidity:\r\n"+JSON.stringify(s,null,2)),a}});function z(){c||(c=new O(S.d)),u||(u=new C(c))}function O(o){var i=this,c="overflow",u="hidden",f="scroll",h=l("body"),d=l('
'),v=d[0],p=l(d.children("div").first()),y=v[a.oH];h.append(d),0===y&&d.hide().show();var x,w,m,b,g,S,z,O,C,M=k(v),H={x:0===M.x,y:0===M.y};function W(t){var r=!1,o="Webkit Moz ms O".split(" "),i=e.createElement("div"),a=null,s=0;if(t=t.toLowerCase(),i.style[t]!==n&&(r=!0),!r)for(a=t.charAt(0).toUpperCase()+t.substr(1);s0?O=C(x[m](b+5,x[w](".",b)),10):g>0?O=C(x[m](z+3,x[w](".",z)),10):S>0&&(O=C(x[m](S+5,x[w](".",S)),10)),O),cssCalc:function(){var t,n,r=e.createElement("div"),o=["calc","-webkit-calc","-moz-calc","-o-calc"];for(t=0;t0){var t=r.wW(),u=r.wH(),f=t-e,v=u-n;if(0===f&&0===v)return;var p=Math.round(t/(e/100)),y=Math.round(u/(n/100)),x=Math.abs(f),w=Math.abs(v),m=Math.abs(p),b=Math.abs(y),g=c(),S=x>2&&w>2,z=!a(m,b);!(S&&z&&(g!==o&&o>0))||(h.append(d),i.nativeScrollbarSize=k(d[0]),d.remove(),l.each(s.all(),function(){s.has(this)&&s.get(this).update("zoom")})),e=t,n=u,o=g}})}function a(t,e){var n=Math.abs(t),r=Math.abs(e);return!(n===r||n+1===r||n-1===r)}function c(){var e=t.screen.deviceXDPI||0,n=t.screen.logicalXDPI||1;return t.devicePixelRatio||e/n}}()}function C(t){var e,o=this,i="autoUpdate",a=i+"Interval",s=[],c=[],u=!1,f=33,h=f,d=r.now(),v=function(){if(s.length>0&&u){e=r.rAF()(function(){v()});var t=r.now(),o=t-d;if(o>h){d=t-o%h;for(var l=f,p=0;pm&&(y.update("auto"),c[p]=new Date(b+=m)),l=Math.max(1,Math.min(l,m))}}h=l}}else h=f};o.add=function(e){-1===l.inArray(e,s)&&(s.push(e),c.push(r.now()),s.length>0&&!u&&(u=!0,t.autoUpdateLoop=u,v()))},o.remove=function(o){var i=l.inArray(o,s);i>-1&&(c.splice(i,1),s.splice(i,1),0===s.length&&u&&(u=!1,t.autoUpdateLoop=u,e!==n&&(r.cAF()(e),e=-1)))}}function M(e,c,u,f){if(no(e)){if(s.has(e)){var h=s.get(e);return h.options(c),h}var d,v,p,y,x,w,m,b,g,z,O,C,M,H,W,k,A,T,E,L,R,D,P,N,_,F,I,j,U,B,V,q,X,Y,K,Q,J,G,Z,$,tt,et,nt,rt,ot,it,at,st,lt,ct,ut,ft,ht,dt,vt,pt,yt,xt,wt,mt,bt,gt,St,zt,Ot,Ct,Mt,Ht,Wt,kt,At,Tt,Et,Lt,Rt,Dt,Pt,Nt,_t,Ft,It,jt,Ut,Bt,Vt,qt,Xt,Yt,Kt,Qt,Jt,Gt,Zt,$t,te,ee,ne,re,oe,ie,ae,se,le,ce,ue,fe,he,de,ve,pe,ye,xe,we,me,be,ge,Se,ze,Oe=new t[o],Ce={},Me={},He={},We={},ke={},Ae=175,Te="-hidden",Ee="margin-",Le="padding-",Re="border-",De="top",Pe="right",Ne="bottom",_e="left",Fe="min-",Ie="max-",je="width",Ue="height",Be="float",Ve="",qe="auto",Xe="scroll",Ye="100%",Ke="x",Qe="y",Je=".",Ge=" ",Ze="scrollbar",$e="-horizontal",tn="-vertical",en=Xe+"Left",nn=Xe+"Top",rn="mousedown touchstart",on="mouseup touchend",an="mousemove touchmove",sn="mouseenter",ln="mouseleave",cn="keydown",un="keyup",fn="selectstart",hn="transitionend webkitTransitionEnd oTransitionEnd",dn="__overlayScrollbarsRO__",vn="os-",pn=vn+"html",yn=vn+"host",xn=yn+"-textarea",wn=yn+"-"+Ze+$e+Te,mn=yn+"-"+Ze+tn+Te,bn=yn+"-transition",gn=yn+"-rtl",Sn=yn+"-resize-disabled",zn=yn+"-scrolling",On=yn+"-overflow",Cn=On+"-x",Mn=On+"-y",Hn=vn+"textarea",Wn=Hn+"-cover",kn=vn+"padding",An=vn+"viewport",Tn=An+"-native-scrollbars-invisible",En=An+"-native-scrollbars-overlaid",Ln=vn+"content",Rn=vn+"content-arrange",Dn=vn+"content-glue",Pn=vn+"size-auto-observer",Nn=vn+"resize-observer",_n=vn+"resize-observer-item",Fn=_n+"-final",In=vn+"text-inherit",jn=vn+Ze,Un=jn+"-track",Bn=Un+"-off",Vn=jn+"-handle",qn=Vn+"-off",Xn=jn+"-unusable",Yn=jn+"-"+qe+Te,Kn=jn+"-corner",Qn=Kn+"-resize",Jn=Qn+"-both",Gn=Qn+$e,Zn=Qn+tn,$n=jn+$e,tr=jn+tn,er=vn+"dragging",nr=vn+"theme-none",rr={},or=33,ir=[],ar=11,sr=[112,113,114,115,116,117,118,119,120,121,123,33,34,37,38,39,40,16,17,18,19,20,144],lr=[],cr={},ur={};if(Oe.sleep=function(){I=!0},Oe.update=function(t){var e,n,r="zoom"===t,o="img",i="load";t===qe?(e=jr(),n=Ir(),(e||n)&&Vr(!1,n)):r?Vr(!0,!0):(t=I||t,I=!1,Vr(!1,!1,t)),k||r||it.find(o).each(function(t,e){-1===l.inArray(e,ir)&&(e=l(e)).off(i,Pr).on(i,Pr)})},Oe.options=function(t,e){if(l.isEmptyObject(t)||!l.isPlainObject(t)){if(xo(t)===i.s){if(arguments.length>=2){var n={};return ho(n,t,e),qr(n),void Vr()}return fo(B,t)}return B}qr(t);var r=I||!1;I=!1,Vr(),I=r},Oe.destroy=function(){W=!0,f.remove(Oe),wr(),vr(tt),E&&vr($),go(tt),et!==n&&go(et),ot!==n&&go(ot),E&&go($),O?(hr(Z,an,Sr),hr(Z,sn,br),hr(Z,ln,gr)):Z.off(an,Sr).off(sn,br).off(ln,gr),go(lt),go(ft),st&&go(st),be||Rr(),it.contents().unwrap().unwrap().unwrap(),A&&bo(Q,pn),k?(G.off(Xe,Tr).off("drop",Wr).off("focus",kr).off("focusout",Ar),x>9||!y?G.off("input",Cr):G.off(cn,Mr).off(un,Hr),go(at),bo(G,Hn+Ge+In).unwrap().removeAttr(a.s),go(Z)):(bo(G,yn),bo(Z,[yn,Sn,gn,wn,mn,bn,zn,On,Cn,Mn,nr,$t].join(Ge)));for(var t=0;t0)e.x=t[0],e.y=t[1];else if(xo(t)===i.s||xo(t)===i.n)e.x=t,e.y=t;else if(xo(t)===i.o){for(var n in t=wo({},t),x=0,t)t.hasOwnProperty(n)&&(x>2&&delete t[n],x++);var r=function(e){var n=e?w:m;for(x=0;x2){var y=r.substr(0,2);for(x=0;x/g,(d?"-":Ve)+Ye))[v](/px/g,Ve))[v](/%/g,f+u*(h&&p.n?-1:1)/100))[v](/vw/g,f+We.w))[v](/vh/g,f+We.h),a=oo(t.parseFloat(t.eval(r)).toFixed())}else xo(r)===i.n&&(a=r);if(!isNaN(a)&&a!==n&&xo(a)===i.n){var w=Zt&&h,m=c*(w&&p.n?-1:1),g=w&&p.i,S=w&&p.n;switch(m=g?u-m:m,o){case"+=":s=m+a;break;case"-=":s=m-a;break;case"*=":s=m*a;break;case"/=":s=m/a;break;default:s=a}g&&(s=u-s),S&&(s*=-1),h&&p.n?(s=Math.max(u,s),s=Math.min(0,s)):(s=Math.min(u,s),s=Math.max(0,s)),s===c&&(s=n)}return s};if(L||R){var _=L?E:l(E);if(0===_.length)return;if(T){var I,j,U,B=e.axis,V=e.block,q=xo(V),X=e.margin,Y=xo(X);if(q===i.s)V=[V,V];else if(q===i.a)if((j=V.length)>2||j<1)V=n;else{for(I=!0,1===j&&(V[1]=C),x=0;x=J[e.lt]&&Q[e.lt]+ft[e._wh]<=J[e.lt]+We[e._wh],et[e.xy]=ft[e._wh]o:r0||S){var pt={};if(dt&&(pt[en]=g.x),vt&&(pt[nn]=g.y),S)rt.animate(pt,r);else{var yt={duration:r,complete:s};if(xo(o)===i.a){var xt={};xt[en]=o[0],xt[nn]=o[1],yt.specialEasing=xt}else yt.easing=o;rt.animate(pt,yt)}}else dt&&rt[en](g.x),vt&&rt[nn](g.y)},Oe.scrollStop=function(t,e,n){rt.stop(t,e,n)},Oe.getElements=function(){return{target:G[0],host:Z[0],padding:nt[0],viewport:rt[0],content:it[0],scrollbarHorizontal:{scrollbar:lt[0],track:ct[0],handle:ut[0]},scrollbarVertical:{scrollbar:ft[0],track:ht[0],handle:dt[0]},scrollbarCorner:st}},Oe.getState=function(t){var e=function(t){if(!l.isPlainObject(t))return t;var e=wo(!0,{},t),n=function(t,n){e.hasOwnProperty(t)&&(e[n]=e[t],delete e[t])};return n("w",je),n("h",Ue),delete e.c,e},n={sleeping:e(I)||!1,autoUpdate:e(!ae),widthAuto:e(mt),heightAuto:e(bt),padding:e(zt),overflowAmount:e(Et),hideOverflow:e(wt),hasOverflow:e(xt),contentScrollSize:e(pt),viewportSize:e(We),hostSize:e(vt)};return xo(t)===i.s?fo(n,t):n},So(e,c))return s.add(e,Oe),Oe;Oe=n}function fr(t,e,n){for(var r=e.split(Ge),o=0;o9||!y){t.prepend(uo(Nn,uo({className:_n,dir:"ltr"},uo(_n,uo(Fn))+uo(_n,uo({className:Fn,style:"width: 200%; height: 200%"})))));var d,v,w,m,b=t[0][c][0][c][0],g=l(b[c][1]),S=l(b[c][0]),z=l(S[0][c][0]),O=b[a.oW],M=b[a.oH],H=2,W=u.nativeScrollbarSize,k=function(){S[en](n)[nn](n),g[en](n)[nn](n)},A=function(){v=0,d&&(O=w,M=m,f())},T=function(t){return w=b[a.oW],m=b[a.oH],d=w!=O||m!=M,t&&d&&!v?(r.cAF()(v),v=r.rAF()(A)):t||A(),k(),t&&(r.prvD(t),r.stpP(t)),!1},E={},L={};L[De]=-(W.y+1)*H,L[Pe]=W.x*-H,L[Ne]=W.y*-H,L[_e]=-(W.x+1)*H,l(b).css(L),S.on(Xe,T),g.on(Xe,T),t.on(s,function(){T(!1)}),E[je]=n,E[Ue]=n,z.css(E),k()}else{var R=K[0],D=R.attachEvent,P=!1!==x;if(D)t.prepend(uo(Nn)),co(t,Je+Nn)[0].attachEvent("onresize",f);else{var N=R.createElement(i.o);N.setAttribute("tabindex","-1"),N.setAttribute(a.c,Nn),N.onload=function(){var t=this.contentDocument.defaultView;t.addEventListener("resize",f),t.document.documentElement.style.display="none"},N.type="text/html",P&&t.prepend(N),N.data="about:blank",P||t.prepend(N),t.on(s,f)}}if(t[0]===tt[0]){var _=function(){var e=Z.css("direction"),r={},o=0,i=!1;return e!==Ht&&("ltr"===e?(r[_e]=0,r[Pe]=qe,o=n):(r[_e]=qe,r[Pe]=0,o=p.n?-n:p.i?0:n),tt.children().first().css(r),t[en](o)[nn](n),Ht=e,i=!0),i};_(),t.on(Xe,function(t){return _()&&Vr(),r.prvD(t),r.stpP(t),!1})}}function vr(t){if(C){var e=t.contents()[0];e[dn].disconnect(),delete e[dn]}else go(t.children(Je+Nn).first())}function pr(t){if(t!==n&&C){var e=t.contents()[0];e[dn].unobserve(e)}}function yr(t){if(t!==n&&C){var e=t.contents()[0];e[dn].observe(e)}}function xr(){se&&!ae&&(oe.observe(Z[0],{attributes:!0,attributeOldValue:!0,attributeFilter:[a.i,a.c,a.s]}),ie.observe(k?G[0]:it[0],{attributes:!0,attributeOldValue:!0,subtree:!k,childList:!k,characterData:!k,attributeFilter:k?["wrap","cols","rows"]:[a.i,a.c,a.s]}),ae=!0)}function wr(){se&&ae&&(oe.disconnect(),ie.disconnect(),ae=!1)}function mr(){if(!I){var t=tt[0],e={w:t[a.sW],h:t[a.sH]};if(H){var n=po(e,Xt);Xt=e,n&&Vr(!0,!1)}else Xt=e}}function br(){ye&&Qr(!0)}function gr(){ye&&!J.hasClass(er)&&Qr(!1)}function Sr(){pe&&(Qr(!0),clearTimeout(fe),fe=setTimeout(function(){pe&&Qr(!1)},100))}function zr(t){var e=V.callbacks;I||(j!==n?clearTimeout(j):((ve||pe)&&Qr(!0),so()||Z.addClass(zn),to(e.onScrollStart,t)),Gr(!0,rt[en]()),Gr(!1,rt[nn]()),to(e.onScroll,t),j=setTimeout(function(){Or(),to(e.onScrollStop,t)},Ae))}function Or(){clearTimeout(j),j=n,(ve||pe)&&Qr(!1),so()||Z.removeClass(zn)}function Cr(){Br(),Oe.update(qe)}function Mr(t){var e=t.keyCode;if(!ao(e)){if(0===lr.length){var n=function(){Br(),Oe.update(qe)};n(),le=setInterval(n,1e3/60)}-1===l.inArray(e,lr)&&lr.push(e)}}function Hr(t){var e=t.keyCode;if(!ao(e)){var n=l.inArray(e,lr);n>-1&&lr.splice(n,1),0===lr.length&&(Br(),Oe.update(qe),clearInterval(le))}}function Wr(){setTimeout(function(){Br(),Oe.update(qe)},50)}function kr(){ce=!0}function Ar(){ce=!1,clearInterval(le),lr=[],Br(),Oe.update(qe)}function Tr(t){return G[en](p.i&&Zt?9999999:0),G[nn](0),r.prvD(t),r.stpP(t),!1}function Er(t){if(!I){var e=(t.originalEvent||t).touches!==n;(1===r.mBtn(t)||e)&&(ae&&(me=!0,wr()),cr=r.page(t),ur.w=Z[0][a.oW]-(T?0:L),ur.h=Z[0][a.oH]-(T?0:R),K.on(fn,Dr).on(an,Lr).on(on,Rr),J.addClass(er),st.setCapture&&st.setCapture(),r.prvD(t),r.stpP(t))}}function Lr(t){var e=r.page(t),n={};(Se||ge)&&(n[je]=ur.w+e.x-cr.x),(ze||ge)&&(n[Ue]=ur.h+e.y-cr.y),Z.css(n),r.stpP(t)}function Rr(t){var e=t!==n;K.off(fn,Dr).off(an,Lr).off(on,Rr),J.removeClass(er),st.releaseCapture&&st.releaseCapture(),e&&(me&&xr(),Oe.update(qe)),me=!1}function Dr(t){return r.prvD(t),!1}function Pr(){Vr()}function Nr(){var t={};return A&&ot&&(t.w=oo(ot.css(Fe+je)),t.h=oo(ot.css(Fe+Ue)),t.c=po(t,re),t.f=!0),re=t,t.c}function _r(t,e){var r=e!==n&&null!==e?e.split(Ge):Ve,o=t!==n&&null!==t?t.split(Ge):Ve;if(r===Ve&&o===Ve)return!1;var i,a,s,c,u=ro(o,r),f=!1,h=te!==n&&null!==te?te.split(Ge):[Ve],d=$t!==n&&null!==$t?$t.split(Ge):[Ve],v=l.inArray(nr,u),p=u[i];for(v>-1&&u.splice(v,1),i=0;i0&&H&&i-q0?ft:nr)),se&&(!0===ie?(wr(),f.add(Oe)):null===ie&&y?(wr(),f.add(Oe)):(f.remove(Oe),xr())),qt)if(Vt)if(et===n&&(et=l(uo(Dn)),nt.before(et)),E)$.show();else{$=l(uo(Pn)),et.before($);var He={w:-1,h:-1};dr($,function(){var t={w:$[0][a.oW],h:$[0][a.oH]};po(t,He)&&(H&&bt&&t.h>0||mt&&t.w>0?Vr():(H&&!bt&&0===t.h||!mt&&0===t.w)&&Vr()),He=t}),E=!0,null!==m&&$.css(Ue,m+"(100% + 1px)")}else E&&$.hide();o&&(tt.find("*").trigger(Xe),E&&$.find("*").trigger(Xe));var Ae,Te=Z.css("direction"),Je=vo(Te,Mt,o),Ze=Z.css("box-sizing"),$e=vo(Ze,St,o),tn={c:o,t:oo(Z.css(Le+De)),r:oo(Z.css(Le+Pe)),b:oo(Z.css(Le+Ne)),l:oo(Z.css(Le+_e))};try{Ae=E?$[0].getBoundingClientRect():null}catch(jo){return}T="border-box"===Ze;var on=(F="rtl"===Te)?_e:Pe,cn=F?Pe:_e,un=Z[0],fn=nt[0],hn=!1,dn=!(!E||"none"===Z.css(Be))&&(0===Math.round(Ae.right-Ae.left)&&(!!It||un[a.cW]-L>0));if(Vt&&!dn){var vn=un[a.oW],pn=et.css(je);et.css(je,qe);var yn=un[a.oW];et.css(je,pn),(hn=vn!==yn)||(et.css(je,vn+1),yn=un[a.oW],et.css(je,pn),hn=vn!==yn)}var xn=(dn||hn)&&Vt,wn=vo(xn,mt,o),mn=!xn&&mt,bn=!!E&&0===Math.round(Ae.bottom-Ae.top),Hn=vo(bn,bt,o),Wn=!bn&&bt,kn="-"+je,An=xn&&T||!T,Tn=bn&&T||!T,En={c:o,t:Tn?oo(Z.css(Re+De+kn)):0,r:An?oo(Z.css(Re+Pe+kn)):0,b:Tn?oo(Z.css(Re+Ne+kn)):0,l:An?oo(Z.css(Re+_e+kn)):0},Ln={c:o,t:oo(Z.css(Ee+De)),r:oo(Z.css(Ee+Pe)),b:oo(Z.css(Ee+Ne)),l:oo(Z.css(Ee+_e))},Nn={h:String(Z.css(Ie+Ue)),w:String(Z.css(Ie+je))},_n={},Fn={};if(L=tn.l+tn.r,R=tn.t+tn.b,tn.c=yo(tn,zt),D=En.l+En.r,P=En.t+En.b,En.c=yo(En,Ot),N=Ln.l+Ln.r,_=Ln.t+Ln.b,Ln.c=yo(Ln,Ct),Nn.ih=oo(Nn.h),Nn.iw=oo(Nn.w),Nn.ch=Nn.h.indexOf("px")>-1,Nn.cw=Nn.w.indexOf("px")>-1,Nn.c=po(Nn,gt,o),Mt=Te,St=Ze,mt=xn,bt=bn,zt=tn,Ot=En,Ct=Ln,gt=Nn,Je&&E&&$.css(Be,cn),tn.c||Je||jt||wn||Hn||$e||qt){var In={},jn={};eo(Fn,Ee,[-tn.t,-tn.r,-tn.b,-tn.l]),It?(eo(In,Ve,[tn.t,tn.r,tn.b,tn.l]),eo(k?jn:_n,Le)):(eo(In,Ve),eo(k?jn:_n,Le,[tn.t,tn.r,tn.b,tn.l])),nt.css(In),G.css(jn)}We={w:fn[a.oW],h:fn[a.oH]};var Un=!!k&&Br();if(bn&&(Hn||jt||$e||Nn.c||tn.c||En.c)?(Nn.cw&&(_n[Ie+Ue]=Nn.ch?Nn.ih-(It?R:0)+(T?-P:R):Ve),_n[Ue]=qe):(Hn||jt)&&(_n[Ie+Ue]=Ve,_n[Ue]=Ye),xn&&(wn||jt||$e||Nn.c||tn.c||En.c||Je)?(Nn.cw&&(_n[Ie+je]=Nn.cw?Nn.iw-(It?L:0)+(T?-D:L)+(d.y?v.y:0):Ve),_n[je]=qe,Fn[Ie+je]=Ye):(wn||jt)&&(_n[Ie+je]=Ve,_n[je]=Ye,_n[Be]=Ve,Fn[Ie+je]=Ve),xn&&(Nn.cw||(_n[Ie+je]=Ve),Fn[je]=k&&fe?Un.dw:qe,_n[je]=qe,_n[Be]=cn),bn&&(Nn.ch||(_n[Ie+Ue]=Ve),Fn[Ue]=k?me?Un.dh:qe:it[0][a.cH]),Vt&&et.css(Fn),it.css(_n),_n={},Fn={},xt=xt||{x:!1,y:!1},t||e||Je||$e||jt||wn||xn||Hn||bn||Nn.c||oe||ue||Bt||Ht||Y||we||Me||Ft||jt||we||Me||o){var Bn="overflow",Vn=Bn+"-x",qn=Bn+"-y",Xn="hidden",Yn="visible",Kn=M&&(d.x||d.y||We.w0&&(Fn[je]=Math.max(1,Fn[je]),Fn[Ue]=Math.max(1,Fn[Ue])),k&&at.css(Or),et.css(Fn)}xn&&(_n[je]=Ye),!xn||T||ae||(_n[Be]="none"),it.css(_n),_n={};var Cr=ir.getBoundingClientRect(),Mr={w:Math.max(ir[a.sW],ar[a.sW]),h:Math.max(ir[a.sH],ar[a.sH])};if(Kn&&it.css(Bn,Ve),Cr.width){var Hr=Cr.width,Wr=Cr.height,kr=.001;Mr.w+=oo(Hr+kr)-Hr,Mr.h+=oo(Wr+kr)-Wr}Mr.c=e=po(Mr,pt,o),pt=Mr,t=po(ur={w:un[a.cW],h:un[a.cH]},vt),vt=ur,We={w:fn[a.oW],h:fn[a.oH]};var Ar={x:"v-s"===le.x,y:"v-s"===le.y},Tr={x:"v-h"===le.x,y:"v-h"===le.y},Lr={x:"s"===le.x,y:"s"===le.y},Rr={x:Math.max(0,Math.round(100*(Mr.w-ur.w+(It?L:0)))/100),y:Math.max(0,Math.round(100*(Mr.h-ur.h+(It?R:0)))/100)},Dr=k&&(0===We.w||0===We.h);Dr&&(Rr.x=0,Rr.y=0);var Pr={x:Rr.x>0,y:Rr.y>0},_r={x:Pr.x,y:Pr.y};(Ar.x||Tr.x)&&(_r.x=Pr.y&&!Ar.y&&!Tr.y),(Ar.y||Tr.y)&&(_r.y=Pr.x&&!Ar.x&&!Tr.x),_r.xs=!!_r.x&&(Lr.x||Ar.x),_r.ys=!!_r.y&&(Lr.y||Ar.y);var Fr={x:Pr.x&&_r.xs,y:Pr.y&&_r.ys},Ir=Et;if(Rr.c=po(Rr,Et,Ke,Qe,o),Et=Rr,Pr.c=po(Pr,xt,Ke,Qe,o),xt=Pr,_r.c=po(_r,wt,Ke,Qe,o),wt=_r,d.x||d.y){var jr=o,Ur={};if((Pr.x||Pr.y)&&(Ur.w=d.y&&Pr.y?Mr.w+v.y:Ve,Ur.h=d.x&&Pr.x?Mr.h+v.x:Ve,jr=vo(Ur,yt,o),yt=Ur),Pr.c||_r.c||Mr.c||Je||wn||Hn||xn||bn||oe){var qr="px solid transparent";_n[Re+cn]=Ve,_n[Ee+cn]=Ve,d.x&&Pr.x&&_r.xs?(bn&&(_n[Ee+Ne]=Xt?Ve:v.x),_n[Re+Ne]=bn||Xt?Ve:v.x+qr):(Ur.h=Ve,jr=!0,_n[Re+Ne]=Ve,_n[Ee+Ne]=Ve),d.y&&Pr.y&&_r.ys?(xn&&(_n[Ee+on]=Xt?Ve:v.y),_n[Re+on]=Xt?Ve:v.y+qr):(Ur.w=Ve,jr=!0,_n[Re+on]=Ve,_n[Ee+on]=Ve)}if(Xt&&(Ur.w=Ve,Ur.h=Ve,jr=!0),jr){var Xr={};Xr[je]=_r.y?Ur.w:Ve,Xr[Ue]=_r.x?Ur.h:Ve,ot===n&&(ot=l(uo(Rn)),rt.prepend(ot)),ot.css(Xr)}it.css(_n)}var Yr={};In={};if(t||Pr.c||_r.c||Mr.c||ue||$e||oe||Je||Bt||Hn){Yr[cn]=Ve;var $r=function(){Yr[Ne]=Ve,Ce.h=0},no=function(){Yr[on]=Ve,Ce.w=0};if(Pr.x&&_r.xs?(Yr[Vn]=Xe,Xt?$r():(Yr[Ne]=-(d.x?v.x:b.x),Ce.h=d.x?v.y:0)):(Yr[Vn]=Ve,$r()),Pr.y&&_r.ys?(Yr[qn]=Xe,Xt?no():(Yr[on]=-(d.y?v.y:b.y),Ce.w=d.y?v.x:0)):(Yr[qn]=Ve,no()),(We.h-1,Io=_o.y>-1;(Fo||Io)&&(Io&&rt[nn](_o.y),Fo&&(F&&Zt&&p.i?rt[en](0):rt[en](_o.x)))}Nt=ko}else k||(F&&p.i&&d.y&&Pr.x&&Zt&&(c.l+=Ce.w||0),rt[en](c.l),rt[nn](c.t));Je&&to(W,{isRTL:F,dir:Te}),t&&to(U,{width:vt.w,height:vt.h}),e&&to(j,{width:pt.w,height:pt.h}),(Pr.c||_r.c)&&to(z,{x:Pr.x,y:Pr.y,xScrollable:_r.xs,yScrollable:_r.ys,clipped:_r.x||_r.y}),Rr.c&&to(C,{x:Rr.x,y:Rr.y})}A&&(Pr.c||re.c)&&(re.f||Nr(),d.y&&Pr.x&&it.css(Fe+je,re.w+v.y),d.x&&Pr.y&&it.css(Fe+Ue,re.h+v.x),re.c=!1),yr(tt),yr($),to(S,{forced:o})}}function qr(t){B=wo(!0,{},B,S.v(t,S.t,!0)),V=wo(!0,{},V,S.v(t,S.t,!1,!0))}function Xr(){lt=l(uo(jn+Ge+$n)),ct=l(uo(Un)),ut=l(uo(Vn)),ft=l(uo(jn+Ge+tr)),ht=l(uo(Un)),dt=l(uo(Vn)),lt.append(ct),ct.append(ut),ft.append(ht),ht.append(dt),nt.after(ft),nt.after(lt),g&&(lt.on(hn,function(t){t.target===lt[0]&&(Jr(!0),Gr(!0,rt[en]()))}),ft.on(hn,function(t){t.target===ft[0]&&(Jr(!1),Gr(!1,rt[nn]()))})),Yr(!0),Yr(!1),st=l(uo(Kn)),Z.append(st)}function Yr(t){var e,o,i,a=$r(t),s=a.xy,l=Xe+a.LT,c="active",u=1,f=function(){u=.5},h=function(){u=1},d=function(n){var i=a.i.tl,c=a.i.hl,u=a.i.ms*((c/2+r.page(n)[s]-o-c/2)/(i-c));u=isFinite(u)?u:0,F&&t&&(p.n||!p.n&&!p.i)&&(u*=-1),rt[l](e+u),O||r.prvD(n)},v=function(t){t=t||t.originalEvent,bo(J,er),bo(a.h,c),bo(a.t,c),bo(a.s,c),O?(hr(K,an,d),hr(K,on,v),hr(K,cn,y),hr(K,un,x)):K.off(an,d).off(on,v).off(cn,y).off(un,x),K.off(fn,Dr),h(),e=n,o=n,i!==n&&(Oe.scrollStop(),clearTimeout(i),i=n);var r=Z[0].getBoundingClientRect();t.clientX>=r.left&&t.clientX<=r.right&&t.clientY>=r.top&&t.clientY<=r.bottom||gr(),(ve||pe)&&Qr(!1)},y=function(t){16==t.keyCode&&f()},x=function(t){16==t.keyCode&&h()};a.h.on(rn,function(i){if(!I){var u=(i.originalEvent||i).touches!==n;so()||!Jt||u&&!xe||(1===r.mBtn(i)||u)&&(e=(e=rt[l]())===n?0:e,(F&&t&&!p.n||!F)&&(e=e<0?0:e),o=r.page(i)[s],mo(J,er),mo(a.h,c),mo(a.s,c),O?(fr(K,an,d),fr(K,on,v)):K.on(an,d).on(on,v),K.on(fn,Dr),r.prvD(i))}}),a.t.on(rn,function(e){if(!I){var l=(e.originalEvent||e).touches!==n;if(!so()&&Qt&&(!l||xe)&&(1===r.mBtn(e)||l)){var h,d=We[a._wh],w=a.t.offset()[a.lt],m=!0;e.shiftKey&&f();var b=function(){var e=a.i.ho,r=a.i.hl,s=o-w,l=200*u,c=m?Math.max(333,l):l,f={},v=F&&t&&(!p.i&&!p.n||Zt),y=e>s;v&&(y=e=s;v&&(x=h?e+r>=s:e<=s),x?(clearTimeout(i),Oe.scrollStop(),i=n):i=setTimeout(b,c),m=!1};o=r.page(e)[s],mo(J,er),mo(a.t,c),mo(a.s,c),O?(fr(K,on,v),fr(K,cn,y),fr(K,un,x)):K.on(on,v).on(cn,y).on(un,x),K.on(fn,Dr),b(),r.prvD(e)}}}).hover(function(){(ve||pe)&&(we=!0,Qr(!0))},function(){(ve||pe)&&(we=!1,Qr(!1))}),a.s.on(rn,function(t){r.stpP(t)})}function Kr(t,e,n){var r=t?wn:mn,o=t?lt:ft;e?Z.removeClass(r):Z.addClass(r),n?o.removeClass(Xn):o.addClass(Xn)}function Qr(t,e){if(clearTimeout(ue),t)lt.removeClass(Yn),ft.removeClass(Yn);else{var n="active",r=function(){if(!we){var t=ut.hasClass(n)||dt.hasClass(n);!t&&(ve||pe||ye)&<.addClass(Yn),!t&&(ve||pe||ye)&&ft.addClass(Yn)}};he>0&&!0!==e?ue=setTimeout(r,he):r()}}function Jr(t){var e={},n=$r(t),r=Math.min(1,(vt[n._wh]-(Wt?t?L:R:0))/pt[n._wh]);e[n.wh]=Math.floor(100*r*1e5)/1e5+"%",so()||n.h.css(e),n.i.hl=n.h[0]["offset"+n.WH],n.i.hlr=r}function Gr(t,e){var n,r,o=F&&t,i={},a=$r(t),s="translate(",l="transform",c=rt[0][Xe+a.WH]-rt[0]["client"+a.WH],u=a.i.hl,f=a.t[0]["offset"+a.WH],h=f-u;p.n&&o&&(c*=-1),r=e/c,r=isNaN(r)?0:Math.min(1,r),a.i.ms=c,a.i.cs=e,a.i.csr=r,h*=r,h=isNaN(h)?0:h,o&&(p.n||!p.n&&!p.i)&&(h=f-u-h),h=Math.max(0,h),z?(o&&(h=-(f-u-h)),n=t?s+h+"px, 0px)":s+"0px, "+h+"px)",i["-webkit-"+l]=n,i["-moz-"+l]=n,i["-ms-"+l]=n,i["-o-"+l]=n,i[l]=n):i[a.lt]=h,so()||a.h.css(i),a.i.ho=h,a.i.tl=f}function Zr(t,e){var n=e?"removeClass":"addClass",r=t?ht:dt,o=t?Bn:qn;(t?ct:ut)[n](o),r[n](o)}function $r(t){return{wh:t?je:Ue,WH:t?"Width":"Height",lt:t?_e:De,LT:t?"Left":"Top",xy:t?Ke:Qe,XY:t?"X":"Y",_wh:t?"w":"h",_lt:t?"l":"t",t:t?ct:ht,h:t?ut:dt,s:t?lt:ft,i:t?Me:He}}function to(t,e){H&&l.isFunction(t)&&t.call(Oe,e)}function eo(t,e,r){r===n&&(r=[Ve,Ve,Ve,Ve]),t[e+De]=r[0],t[e+Pe]=r[1],t[e+Ne]=r[2],t[e+_e]=r[3]}function no(e){return typeof t.HTMLElement===i.o?e instanceof t.HTMLElement:e&&typeof e===i.o&&null!==e&&1===e.nodeType&&typeof e.nodeName===i.s}function ro(t,e){var n,r=[],o=[];for(n=0;nu&&(c=r+1,u=e);return{cursorRow:f,cursorCol:h,rows:s,cols:u,wRow:c,pos:t,max:i}}}function ao(t){for(var e=0;e"+(e||Ve)+""}function fo(t,e){for(var n,r=e.split(Je),o=0;o9||!y?G.on("input",Cr):G.on(cn,Mr).on(un,Hr)}else mo(G,yn),(Z=G).wrapInner(uo(Ln)).wrapInner(uo(An)).wrapInner(uo(kn)),it=co(Z,Je+Ln),rt=co(Z,Je+An),nt=co(Z,Je+kn),it.on(hn,function(t){!0!==Rt&&Ur((t=t.originalEvent||t).propertyName)&&Vr(qe)});if(Xr(),O?fr(rt,Xe,zr):rt.on(Xe,zr),w&&mo(rt,d.x&&d.y?En:Tn),se){var s,c,f,h,S,T,E=r.mO(),L=r.now();oe=new E(function(t){if(H&&!I){var e,n=!1;l.each(t,function(){if(s=(e=this).target,c=e.attributeName,n=c===a.c?_r(e.oldValue,s.className):c!==a.s||e.oldValue!==s.style.cssText)return!1}),n&&Oe.update(qe)}}),ie=new E(function(t){if(H&&!I){var e=!1;l.each(t,function(){return!(e=Fr(this))}),e&&(h=r.now(),S=bt||mt,T=function(){L=h,k&&Br(),S?Oe.update():Oe.update(qe)},clearTimeout(f),ar<=0||h-L>ar||!S?T():f=setTimeout(T,ar))}})}return A&&(mo(Q,pn),rt[en](n.l),rt[nn](n.t)),tt=l(uo("os-resize-observer-host")),Z.prepend(tt),dr(tt,mr),mr(),Oe.update(qe),setTimeout(function(){g&&!W&&mo(Z,bn)},333),H=!0,to(o.onInitialized),H}}return t[o]=function(e,r){if(0===arguments.length)return this;z();var i,a,f=[];return l.isPlainObject(r)?e&&e.length?(l.each(e,function(){i=this,console.log(i),i!==n&&f.push(M(i,r,c,u))}),a=f.length>1?f:f[0]):a=M(e,r,c,u):e&&(e.length&&e.length>0?(l.each(e,function(){i=s.get(this),"!"===r?i instanceof t[o]&&f.push(i):f.push(i)}),a=f.length>1?f:f[0]):a=s.get(e)),a},t[o].globals=function(){z();var t=l.extend(!0,{},c);return delete t.msie,t},t[o].defaultOptions=function(t){z();var e=c.defaultOptions;if(t===n)return l.extend(!0,{},e);c.defaultOptions=l.extend(!0,{},e,S.v(t,S.t,!0))},t[o]}({wW:function(){return t.innerWidth||e.documentElement[a.cW]||e.body[a.cW]},wH:function(){return t.innerHeight||e.documentElement[a.cH]||e.body[a.cH]},mO:function(){return t.MutationObserver||t.WebKitMutationObserver||t.WebkitMutationObserver||t.MozMutationObserver||n},rO:function(){return t.ResizeObserver||t.WebKitResizeObserver||t.WebkitResizeObserver||t.MozResizeObserver||n},rAF:function(){return t.requestAnimationFrame||t.webkitRequestAnimationFrame||t.mozRequestAnimationFrame||t.oRequestAnimationFrame||t.msRequestAnimationFrame||function(e){return t.setTimeout(e,1e3/60)}},cAF:function(){return t.cancelAnimationFrame||t.webkitCancelAnimationFrame||t.mozCancelAnimationFrame||t.oCancelAnimationFrame||t.msCancelAnimationFrame||function(e){return t.clearTimeout(e)}},now:function(){return Date.now()||(new Date).getTime()},stpP:function(t){t.stopPropagation?t.stopPropagation():t.cancelBubble=!0},prvD:function(t){t.preventDefault?t.preventDefault():t.returnValue=!1},page:function(t){var r="page",o="client",i="X",a="Y",s=((t=t.originalEvent||t).target||t.srcElement||e).ownerDocument||e,l=s.documentElement,c=s.body;if(t.touches!==n){var u=t.touches[0];return{x:u[r+i],y:u[r+a]}}return!t[r+i]&&t[o+i]&&null!=t[o+i]?{x:t[o+i]+(l&&l.scrollLeft||c&&c.scrollLeft||0)-(l&&l.clientLeft||c&&c.clientLeft||0),y:t[o+a]+(l&&l.scrollTop||c&&c.scrollTop||0)-(l&&l.clientTop||c&&c.clientTop||0)}:{x:t[r+i],y:t[r+a]}},mBtn:function(t){return t.which||t.button===n?t.which:1&t.button?1:2&t.button?3:4&t.button?2:0},bind:function(t,e){if(typeof t!==i.f)throw"Can't bind function!";var n=Array.prototype.slice.call(arguments,2),r=function(){},o=function(){return t.apply(this instanceof r?this:e,n.concat(Array.prototype.slice.call(arguments)))};return t.prototype&&(r.prototype=t.prototype),o.prototype=new r,o}},function(t){var e=[],r="__overlayScrollbars__";function o(t,n){t[r]=n,e.push(t)}function i(n){var o=t.inArray(n,e);o>-1&&(delete n[r],e.splice(o,1))}function a(t){return s(t)!==n}function s(t){for(var n=0;n