|
|
@@ -0,0 +1,5982 @@
|
|
|
+/*!
|
|
|
+* fullPage 4.0.20
|
|
|
+* https://github.com/alvarotrigo/fullPage.js
|
|
|
+*
|
|
|
+* @license GPLv3 for open source use only
|
|
|
+* or Fullpage Commercial License for commercial use
|
|
|
+* http://alvarotrigo.com/fullPage/pricing/
|
|
|
+*
|
|
|
+* Copyright (C) 2018 http://alvarotrigo.com/fullPage - A project by Alvaro Trigo
|
|
|
+*/
|
|
|
+
|
|
|
+(function (global, factory) {
|
|
|
+ typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
|
|
|
+ typeof define === 'function' && define.amd ? define(factory) :
|
|
|
+ (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.fullpage = factory());
|
|
|
+})(this, (function () { 'use strict';
|
|
|
+
|
|
|
+ // https://tc39.github.io/ecma262/#sec-array.prototype.find
|
|
|
+ if (!Array.prototype.find) {
|
|
|
+ Object.defineProperty(Array.prototype, 'find', {
|
|
|
+ value: function value(predicate) {
|
|
|
+ // 1. Let O be ? ToObject(this value).
|
|
|
+ if (this == null) {
|
|
|
+ throw new TypeError('"this" is null or not defined');
|
|
|
+ }
|
|
|
+
|
|
|
+ var o = Object(this); // 2. Let len be ? ToLength(? Get(O, "length")).
|
|
|
+
|
|
|
+ var len = o.length >>> 0; // 3. If IsCallable(predicate) is false, throw a TypeError exception.
|
|
|
+
|
|
|
+ if (typeof predicate !== 'function') {
|
|
|
+ throw new TypeError('predicate must be a function');
|
|
|
+ } // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.
|
|
|
+
|
|
|
+
|
|
|
+ var thisArg = arguments[1]; // 5. Let k be 0.
|
|
|
+
|
|
|
+ var k = 0; // 6. Repeat, while k < len
|
|
|
+
|
|
|
+ while (k < len) {
|
|
|
+ // a. Let Pk be ! ToString(k).
|
|
|
+ // b. Let kValue be ? Get(O, Pk).
|
|
|
+ // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
|
|
|
+ // d. If testResult is true, return kValue.
|
|
|
+ var kValue = o[k];
|
|
|
+
|
|
|
+ if (predicate.call(thisArg, kValue, k, o)) {
|
|
|
+ return kValue;
|
|
|
+ } // e. Increase k by 1.
|
|
|
+
|
|
|
+
|
|
|
+ k++;
|
|
|
+ } // 7. Return undefined.
|
|
|
+
|
|
|
+
|
|
|
+ return undefined;
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ // Production steps of ECMA-262, Edition 6, 22.1.2.1
|
|
|
+ if (!Array.from) {
|
|
|
+ Array.from = function () {
|
|
|
+ var toStr = Object.prototype.toString;
|
|
|
+
|
|
|
+ var isCallable = function isCallable(fn) {
|
|
|
+ return typeof fn === 'function' || toStr.call(fn) === '[object Function]';
|
|
|
+ };
|
|
|
+
|
|
|
+ var toInteger = function toInteger(value) {
|
|
|
+ var number = Number(value);
|
|
|
+
|
|
|
+ if (isNaN(number)) {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (number === 0 || !isFinite(number)) {
|
|
|
+ return number;
|
|
|
+ }
|
|
|
+
|
|
|
+ return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number));
|
|
|
+ };
|
|
|
+
|
|
|
+ var maxSafeInteger = Math.pow(2, 53) - 1;
|
|
|
+
|
|
|
+ var toLength = function toLength(value) {
|
|
|
+ var len = toInteger(value);
|
|
|
+ return Math.min(Math.max(len, 0), maxSafeInteger);
|
|
|
+ }; // The length property of the from method is 1.
|
|
|
+
|
|
|
+
|
|
|
+ return function from(arrayLike
|
|
|
+ /*, mapFn, thisArg */
|
|
|
+ ) {
|
|
|
+ // 1. Let C be the this value.
|
|
|
+ var C = this; // 2. Let items be ToObject(arrayLike).
|
|
|
+
|
|
|
+ var items = Object(arrayLike); // 3. ReturnIfAbrupt(items).
|
|
|
+
|
|
|
+ if (arrayLike == null) {
|
|
|
+ throw new TypeError('Array.from requires an array-like object - not null or undefined');
|
|
|
+ } // 4. If mapfn is undefined, then let mapping be false.
|
|
|
+
|
|
|
+
|
|
|
+ var mapFn = arguments.length > 1 ? arguments[1] : void undefined;
|
|
|
+ var T;
|
|
|
+
|
|
|
+ if (typeof mapFn !== 'undefined') {
|
|
|
+ // 5. else
|
|
|
+ // 5. a If IsCallable(mapfn) is false, throw a TypeError exception.
|
|
|
+ if (!isCallable(mapFn)) {
|
|
|
+ throw new TypeError('Array.from: when provided, the second argument must be a function');
|
|
|
+ } // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined.
|
|
|
+
|
|
|
+
|
|
|
+ if (arguments.length > 2) {
|
|
|
+ T = arguments[2];
|
|
|
+ }
|
|
|
+ } // 10. Let lenValue be Get(items, "length").
|
|
|
+ // 11. Let len be ToLength(lenValue).
|
|
|
+
|
|
|
+
|
|
|
+ var len = toLength(items.length); // 13. If IsConstructor(C) is true, then
|
|
|
+ // 13. a. Let A be the result of calling the [[Construct]] internal method
|
|
|
+ // of C with an argument list containing the single item len.
|
|
|
+ // 14. a. Else, Let A be ArrayCreate(len).
|
|
|
+
|
|
|
+ var A = isCallable(C) ? Object(new C(len)) : new Array(len); // 16. Let k be 0.
|
|
|
+
|
|
|
+ var k = 0; // 17. Repeat, while k < len… (also steps a - h)
|
|
|
+
|
|
|
+ var kValue;
|
|
|
+
|
|
|
+ while (k < len) {
|
|
|
+ kValue = items[k];
|
|
|
+
|
|
|
+ if (mapFn) {
|
|
|
+ A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k);
|
|
|
+ } else {
|
|
|
+ A[k] = kValue;
|
|
|
+ }
|
|
|
+
|
|
|
+ k += 1;
|
|
|
+ } // 18. Let putStatus be Put(A, "length", len, true).
|
|
|
+
|
|
|
+
|
|
|
+ A.length = len; // 20. Return A.
|
|
|
+
|
|
|
+ return A;
|
|
|
+ };
|
|
|
+ }();
|
|
|
+ }
|
|
|
+
|
|
|
+ var win = window;
|
|
|
+ var doc = document;
|
|
|
+ var isTouchDevice = navigator.userAgent.match(/(iPhone|iPod|iPad|Android|playbook|silk|BlackBerry|BB10|Windows Phone|Tizen|Bada|webOS|IEMobile|Opera Mini)/);
|
|
|
+ var isMacDevice = /(Mac|iPhone|iPod|iPad)/i.test(win.navigator.userAgent); // @ts-ignore
|
|
|
+
|
|
|
+ var isTouch = 'ontouchstart' in win || navigator.msMaxTouchPoints > 0 || navigator.maxTouchPoints;
|
|
|
+ var isIE11 = !!window.MSInputMethodContext && !!document.documentMode; // taken from https://github.com/udacity/ud891/blob/gh-pages/lesson2-focus/07-modals-and-keyboard-traps/solution/modal.js
|
|
|
+
|
|
|
+ var focusableElementsString = 'a[href], area[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, [tabindex="0"], [contenteditable]'; // cache common elements
|
|
|
+
|
|
|
+ var FP = {
|
|
|
+ test: {},
|
|
|
+ shared: {}
|
|
|
+ };
|
|
|
+ var extensions = ['parallax', 'scrollOverflowReset', 'dragAndMove', 'offsetSections', 'fadingEffect', 'responsiveSlides', 'continuousHorizontal', 'interlockedSlides', 'scrollHorizontally', 'resetSliders', 'cards', 'dropEffect', 'waterEffect'];
|
|
|
+
|
|
|
+ /**
|
|
|
+ * forEach polyfill for IE
|
|
|
+ * https://developer.mozilla.org/en-US/docs/Web/API/NodeList/forEach#Browser_Compatibility
|
|
|
+ */
|
|
|
+
|
|
|
+ if (win.NodeList && !NodeList.prototype.forEach) {
|
|
|
+ NodeList.prototype.forEach = function (callback, thisArg) {
|
|
|
+ thisArg = thisArg || window;
|
|
|
+
|
|
|
+ for (var i = 0; i < this.length; i++) {
|
|
|
+ callback.call(thisArg, this[i], i, this);
|
|
|
+ }
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ if (typeof Object.assign != 'function') {
|
|
|
+ // Must be writable: true, enumerable: false, configurable: true
|
|
|
+ Object.defineProperty(Object, 'assign', {
|
|
|
+ value: function assign(target, varArgs) {
|
|
|
+
|
|
|
+ if (target == null) {
|
|
|
+ // TypeError if undefined or null
|
|
|
+ throw new TypeError('Cannot convert undefined or null to object');
|
|
|
+ }
|
|
|
+
|
|
|
+ var to = Object(target);
|
|
|
+
|
|
|
+ for (var index = 1; index < arguments.length; index++) {
|
|
|
+ var nextSource = arguments[index];
|
|
|
+
|
|
|
+ if (nextSource != null) {
|
|
|
+ // Skip over if undefined or null
|
|
|
+ for (var nextKey in nextSource) {
|
|
|
+ // Avoid bugs when hasOwnProperty is shadowed
|
|
|
+ if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
|
|
|
+ to[nextKey] = nextSource[nextKey];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return to;
|
|
|
+ },
|
|
|
+ writable: true,
|
|
|
+ configurable: true
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ // https://stackoverflow.com/questions/51719553/padstart-not-working-in-ie11
|
|
|
+ // https://github.com/behnammodi/polyfill/blob/master/string.polyfill.js
|
|
|
+ // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart
|
|
|
+ if (!String.prototype.padStart) {
|
|
|
+ String.prototype.padStart = function padStart(targetLength, padString) {
|
|
|
+ targetLength = targetLength >> 0; //truncate if number or convert non-number to 0;
|
|
|
+
|
|
|
+ padString = String(typeof padString !== 'undefined' ? padString : ' ');
|
|
|
+
|
|
|
+ if (this.length > targetLength) {
|
|
|
+ return String(this);
|
|
|
+ } else {
|
|
|
+ targetLength = targetLength - this.length;
|
|
|
+
|
|
|
+ if (targetLength > padString.length) {
|
|
|
+ padString += Array.apply(null, Array(targetLength)).map(function () {
|
|
|
+ return padString;
|
|
|
+ }).join("");
|
|
|
+ }
|
|
|
+
|
|
|
+ return padString.slice(0, targetLength) + String(this);
|
|
|
+ }
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ //utils
|
|
|
+ /**
|
|
|
+ * Shows a message in the console of the given type.
|
|
|
+ */
|
|
|
+
|
|
|
+ function showError(type, text) {
|
|
|
+ win.console && win.console[type] && win.console[type]('fullPage: ' + text);
|
|
|
+ }
|
|
|
+ function isVisible(el) {
|
|
|
+ var style = win.getComputedStyle(el);
|
|
|
+ return style.display !== 'none';
|
|
|
+ }
|
|
|
+ function getVisible(elements) {
|
|
|
+ return Array.from(elements).filter(function (e) {
|
|
|
+ return isVisible(e);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Equivalent of jQuery function $().
|
|
|
+ */
|
|
|
+
|
|
|
+ function $(selector, context) {
|
|
|
+ context = arguments.length > 1 ? context : document;
|
|
|
+ return context ? context.querySelectorAll(selector) : null;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Extends a given Object properties and its childs.
|
|
|
+ */
|
|
|
+
|
|
|
+ function deepExtend(out) {
|
|
|
+ out = out || {};
|
|
|
+
|
|
|
+ for (var i = 1, len = arguments.length; i < len; ++i) {
|
|
|
+ var obj = arguments[i];
|
|
|
+
|
|
|
+ if (!obj) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (var key in obj) {
|
|
|
+ if (!obj.hasOwnProperty(key) || key == '__proto__' || key == 'constructor') {
|
|
|
+ continue;
|
|
|
+ } // based on https://javascriptweblog.wordpress.com/2011/08/08/fixing-the-javascript-typeof-operator/
|
|
|
+
|
|
|
+
|
|
|
+ if (Object.prototype.toString.call(obj[key]) === '[object Object]') {
|
|
|
+ out[key] = deepExtend(out[key], obj[key]);
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ out[key] = obj[key];
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return out;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Checks if the passed element contains the passed class.
|
|
|
+ */
|
|
|
+
|
|
|
+ function hasClass(el, className) {
|
|
|
+ if (el == null) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ return el.classList.contains(className);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets the window height. Crossbrowser.
|
|
|
+ */
|
|
|
+
|
|
|
+ function getWindowHeight() {
|
|
|
+ return 'innerHeight' in win ? win.innerHeight : doc.documentElement.offsetHeight;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets the window width.
|
|
|
+ */
|
|
|
+
|
|
|
+ function getWindowWidth() {
|
|
|
+ return win.innerWidth;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Set's the CSS properties for the passed item/s.
|
|
|
+ * @param {NodeList|HTMLElement|Object} items
|
|
|
+ * @param {Object} props css properties and values.
|
|
|
+ */
|
|
|
+
|
|
|
+ function css(items, props) {
|
|
|
+ items = getList(items);
|
|
|
+ var key;
|
|
|
+
|
|
|
+ for (key in props) {
|
|
|
+ if (props.hasOwnProperty(key)) {
|
|
|
+ if (key !== null) {
|
|
|
+ for (var i = 0; i < items.length; i++) {
|
|
|
+ var item = items[i];
|
|
|
+ item.style[key] = props[key];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return items;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets the previous element to the passed element.
|
|
|
+ */
|
|
|
+
|
|
|
+ function prev(item) {
|
|
|
+ return item.previousElementSibling;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets the next element to the passed element.
|
|
|
+ */
|
|
|
+
|
|
|
+ function next(item) {
|
|
|
+ return item.nextElementSibling;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets the last element from the passed list of elements.
|
|
|
+ */
|
|
|
+
|
|
|
+ function last(item) {
|
|
|
+ return item[item.length - 1];
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets index from the passed element.
|
|
|
+ * @param {String} selector is optional.
|
|
|
+ */
|
|
|
+
|
|
|
+ function index(item, selector) {
|
|
|
+ item = isArrayOrList(item) ? item[0] : item;
|
|
|
+ var children = selector != null ? $(selector, item.parentNode) : item.parentNode.childNodes;
|
|
|
+ var num = 0;
|
|
|
+
|
|
|
+ for (var i = 0; i < children.length; i++) {
|
|
|
+ if (children[i] == item) return num;
|
|
|
+ if (children[i].nodeType == 1) num++;
|
|
|
+ }
|
|
|
+
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets an iterable element for the passed element/s
|
|
|
+ */
|
|
|
+
|
|
|
+ function getList(item) {
|
|
|
+ return !isArrayOrList(item) ? [item] : item;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Adds the display=none property for the passed element/s
|
|
|
+ */
|
|
|
+
|
|
|
+ function hide(el) {
|
|
|
+ el = getList(el);
|
|
|
+
|
|
|
+ for (var i = 0; i < el.length; i++) {
|
|
|
+ el[i].style.display = 'none';
|
|
|
+ }
|
|
|
+
|
|
|
+ return el;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Adds the display=block property for the passed element/s
|
|
|
+ */
|
|
|
+
|
|
|
+ function show(el) {
|
|
|
+ el = getList(el);
|
|
|
+
|
|
|
+ for (var i = 0; i < el.length; i++) {
|
|
|
+ el[i].style.display = 'block';
|
|
|
+ }
|
|
|
+
|
|
|
+ return el;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Checks if the passed element is an iterable element or not
|
|
|
+ */
|
|
|
+
|
|
|
+ function isArrayOrList(el) {
|
|
|
+ return Object.prototype.toString.call(el) === '[object Array]' || Object.prototype.toString.call(el) === '[object NodeList]';
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Adds the passed class to the passed element/s
|
|
|
+ */
|
|
|
+
|
|
|
+ function addClass(el, className) {
|
|
|
+ el = getList(el);
|
|
|
+
|
|
|
+ for (var i = 0; i < el.length; i++) {
|
|
|
+ var item = el[i];
|
|
|
+ item.classList.add(className);
|
|
|
+ }
|
|
|
+
|
|
|
+ return el;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Removes the passed class to the passed element/s
|
|
|
+ * @param {String} `className` can be multiple classnames separated by whitespace
|
|
|
+ */
|
|
|
+
|
|
|
+ function removeClass(el, className) {
|
|
|
+ el = getList(el);
|
|
|
+ var classNames = className.split(' ');
|
|
|
+
|
|
|
+ for (var a = 0; a < classNames.length; a++) {
|
|
|
+ className = classNames[a];
|
|
|
+
|
|
|
+ for (var i = 0; i < el.length; i++) {
|
|
|
+ var item = el[i];
|
|
|
+ item.classList.remove(className);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return el;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Appends the given element ot the given parent.
|
|
|
+ */
|
|
|
+
|
|
|
+ function appendTo(el, parent) {
|
|
|
+ parent.appendChild(el);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ Usage:
|
|
|
+
|
|
|
+ var wrapper = document.createElement('div');
|
|
|
+ wrapper.className = 'fp-slides';
|
|
|
+ wrap($('.slide'), wrapper);
|
|
|
+
|
|
|
+ https://jsfiddle.net/qwzc7oy3/15/ (vanilla)
|
|
|
+ https://jsfiddle.net/oya6ndka/1/ (jquery equivalent)
|
|
|
+ */
|
|
|
+
|
|
|
+ function wrap(toWrap, wrapper, isWrapAll) {
|
|
|
+ var newParent;
|
|
|
+ wrapper = wrapper || doc.createElement('div');
|
|
|
+
|
|
|
+ for (var i = 0; i < toWrap.length; i++) {
|
|
|
+ var item = toWrap[i];
|
|
|
+
|
|
|
+ if (isWrapAll && !i || !isWrapAll) {
|
|
|
+ newParent = wrapper.cloneNode(true);
|
|
|
+ item.parentNode.insertBefore(newParent, item);
|
|
|
+ }
|
|
|
+
|
|
|
+ newParent.appendChild(item);
|
|
|
+ }
|
|
|
+
|
|
|
+ return toWrap;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ Usage:
|
|
|
+ var wrapper = document.createElement('div');
|
|
|
+ wrapper.className = 'fp-slides';
|
|
|
+ wrap($('.slide'), wrapper);
|
|
|
+
|
|
|
+ https://jsfiddle.net/qwzc7oy3/27/ (vanilla)
|
|
|
+ https://jsfiddle.net/oya6ndka/4/ (jquery equivalent)
|
|
|
+ */
|
|
|
+
|
|
|
+ function wrapAll(toWrap, wrapper) {
|
|
|
+ wrap(toWrap, wrapper, true);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Usage:
|
|
|
+ * wrapInner(document.querySelector('#pepe'), '<div class="test">afdas</div>');
|
|
|
+ * wrapInner(document.querySelector('#pepe'), element);
|
|
|
+ *
|
|
|
+ * https://jsfiddle.net/zexxz0tw/6/
|
|
|
+ *
|
|
|
+ * https://stackoverflow.com/a/21817590/1081396
|
|
|
+ */
|
|
|
+
|
|
|
+ function wrapInner(parent, wrapper) {
|
|
|
+ parent.appendChild(wrapper);
|
|
|
+
|
|
|
+ while (parent.firstChild !== wrapper) {
|
|
|
+ wrapper.appendChild(parent.firstChild);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Usage:
|
|
|
+ * unwrap(document.querySelector('#pepe'));
|
|
|
+ * unwrap(element);
|
|
|
+ *
|
|
|
+ * https://jsfiddle.net/szjt0hxq/1/
|
|
|
+ *
|
|
|
+ */
|
|
|
+
|
|
|
+ function unwrap(wrapper) {
|
|
|
+ var wrapperContent = doc.createDocumentFragment();
|
|
|
+
|
|
|
+ while (wrapper.firstChild) {
|
|
|
+ wrapperContent.appendChild(wrapper.firstChild);
|
|
|
+ }
|
|
|
+
|
|
|
+ wrapper.parentNode.replaceChild(wrapperContent, wrapper);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * http://stackoverflow.com/questions/22100853/dom-pure-javascript-solution-to-jquery-closest-implementation
|
|
|
+ * Returns the element or `false` if there's none
|
|
|
+ */
|
|
|
+
|
|
|
+ function closest(el, selector) {
|
|
|
+ if (el && el.nodeType === 1) {
|
|
|
+ if (matches(el, selector)) {
|
|
|
+ return el;
|
|
|
+ }
|
|
|
+
|
|
|
+ return closest(el.parentNode, selector);
|
|
|
+ }
|
|
|
+
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Places one element (rel) after another one or group of them (reference).
|
|
|
+ * @param {HTMLElement} reference
|
|
|
+ * @param {HTMLElement|NodeList|String|Array} el
|
|
|
+ * https://jsfiddle.net/9s97hhzv/1/
|
|
|
+ */
|
|
|
+
|
|
|
+ function after(reference, el) {
|
|
|
+ insertBefore(reference, reference.nextSibling, el);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Places one element (rel) before another one or group of them (reference).
|
|
|
+ * @param {HTMLElement} reference
|
|
|
+ * @param {HTMLElement|NodeList|String|Array} el
|
|
|
+ * https://jsfiddle.net/9s97hhzv/1/
|
|
|
+ */
|
|
|
+
|
|
|
+ function before(reference, el) {
|
|
|
+ insertBefore(reference, reference, el);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Based in https://stackoverflow.com/a/19316024/1081396
|
|
|
+ * and https://stackoverflow.com/a/4793630/1081396
|
|
|
+ */
|
|
|
+
|
|
|
+ function insertBefore(reference, beforeElement, el) {
|
|
|
+ if (!isArrayOrList(el)) {
|
|
|
+ if (typeof el == 'string') {
|
|
|
+ el = createElementFromHTML(el);
|
|
|
+ }
|
|
|
+
|
|
|
+ el = [el];
|
|
|
+ }
|
|
|
+
|
|
|
+ for (var i = 0; i < el.length; i++) {
|
|
|
+ reference.parentNode.insertBefore(el[i], beforeElement);
|
|
|
+ }
|
|
|
+ } //http://stackoverflow.com/questions/3464876/javascript-get-window-x-y-position-for-scroll
|
|
|
+
|
|
|
+ function getScrollTop() {
|
|
|
+ var docElement = doc.documentElement;
|
|
|
+ return (win.pageYOffset || docElement.scrollTop) - (docElement.clientTop || 0);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets the siblings of the passed element
|
|
|
+ */
|
|
|
+
|
|
|
+ function siblings(el) {
|
|
|
+ return Array.prototype.filter.call(el.parentNode.children, function (child) {
|
|
|
+ return child !== el;
|
|
|
+ });
|
|
|
+ }
|
|
|
+ function preventDefault(event) {
|
|
|
+ event.preventDefault();
|
|
|
+ }
|
|
|
+ function getAttr(el, attr) {
|
|
|
+ return el.getAttribute(attr);
|
|
|
+ }
|
|
|
+ function docAddEvent(event, callback, options) {
|
|
|
+ doc.addEventListener(event, callback, options === 'undefined' ? null : options);
|
|
|
+ }
|
|
|
+ function windowAddEvent(event, callback, options) {
|
|
|
+ win.addEventListener(event, callback, options === 'undefined' ? null : options);
|
|
|
+ }
|
|
|
+ function docRemoveEvent(event, callback, options) {
|
|
|
+ doc.removeEventListener(event, callback, options === 'undefined' ? null : options);
|
|
|
+ }
|
|
|
+ function windowRemoveEvent(event, callback, options) {
|
|
|
+ win.removeEventListener(event, callback, options === 'undefined' ? null : options);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Determines whether the passed item is of function type.
|
|
|
+ */
|
|
|
+
|
|
|
+ function isFunction(item) {
|
|
|
+ if (typeof item === 'function') {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ var type = Object.prototype.toString.call(item);
|
|
|
+ return type === '[object Function]' || type === '[object GeneratorFunction]';
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Trigger custom events
|
|
|
+ */
|
|
|
+
|
|
|
+ function trigger(el, eventName, data) {
|
|
|
+ var event;
|
|
|
+ data = typeof data === 'undefined' ? {} : data; // Native
|
|
|
+
|
|
|
+ if (typeof win.CustomEvent === "function") {
|
|
|
+ event = new CustomEvent(eventName, {
|
|
|
+ detail: data
|
|
|
+ });
|
|
|
+ } else {
|
|
|
+ event = doc.createEvent('CustomEvent');
|
|
|
+ event.initCustomEvent(eventName, true, true, data);
|
|
|
+ }
|
|
|
+
|
|
|
+ el.dispatchEvent(event);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Polyfill of .matches()
|
|
|
+ */
|
|
|
+
|
|
|
+ function matches(el, selector) {
|
|
|
+ return (el.matches || el.matchesSelector || el.msMatchesSelector || el.mozMatchesSelector || el.webkitMatchesSelector || el.oMatchesSelector).call(el, selector);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Toggles the visibility of the passed element el.
|
|
|
+ */
|
|
|
+
|
|
|
+ function toggle(el, value) {
|
|
|
+ if (typeof value === "boolean") {
|
|
|
+ for (var i = 0; i < el.length; i++) {
|
|
|
+ el[i].style.display = value ? 'block' : 'none';
|
|
|
+ }
|
|
|
+ } //we don't use it in other way, so no else :)
|
|
|
+
|
|
|
+
|
|
|
+ return el;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Creates a HTMLElement from the passed HTML string.
|
|
|
+ * https://stackoverflow.com/a/494348/1081396
|
|
|
+ */
|
|
|
+
|
|
|
+ function createElementFromHTML(htmlString) {
|
|
|
+ var div = doc.createElement('div');
|
|
|
+ div.innerHTML = htmlString.trim(); // Change this to div.childNodes to support multiple top-level nodes
|
|
|
+
|
|
|
+ return div.firstChild;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Removes the passed item/s from the DOM.
|
|
|
+ */
|
|
|
+
|
|
|
+ function remove(items) {
|
|
|
+ items = getList(items);
|
|
|
+
|
|
|
+ for (var i = 0; i < items.length; i++) {
|
|
|
+ var item = items[i];
|
|
|
+
|
|
|
+ if (item && item.parentElement) {
|
|
|
+ item.parentNode.removeChild(item);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } //https://jsfiddle.net/w1rktecz/
|
|
|
+
|
|
|
+ function untilAll(item, selector, fn) {
|
|
|
+ var sibling = item[fn];
|
|
|
+ var siblings = [];
|
|
|
+
|
|
|
+ while (sibling) {
|
|
|
+ if (matches(sibling, selector) || selector == null) {
|
|
|
+ siblings.push(sibling);
|
|
|
+ }
|
|
|
+
|
|
|
+ sibling = sibling[fn];
|
|
|
+ }
|
|
|
+
|
|
|
+ return siblings;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets all next elements matching the passed selector.
|
|
|
+ */
|
|
|
+
|
|
|
+ function nextAll(item, selector) {
|
|
|
+ return untilAll(item, selector, 'nextElementSibling');
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets all previous elements matching the passed selector.
|
|
|
+ */
|
|
|
+
|
|
|
+ function prevAll(item, selector) {
|
|
|
+ return untilAll(item, selector, 'previousElementSibling');
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Converts an object to an array.
|
|
|
+ */
|
|
|
+
|
|
|
+ function toArray(objectData) {
|
|
|
+ return Object.keys(objectData).map(function (key) {
|
|
|
+ return objectData[key];
|
|
|
+ });
|
|
|
+ }
|
|
|
+ function getLast(items) {
|
|
|
+ return items[items.length - 1];
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets the average of the last `number` elements of the given array.
|
|
|
+ */
|
|
|
+
|
|
|
+ function getAverage(elements, number) {
|
|
|
+ var sum = 0; //taking `number` elements from the end to make the average, if there are not enought, 1
|
|
|
+
|
|
|
+ var lastElements = elements.slice(Math.max(elements.length - number, 1));
|
|
|
+
|
|
|
+ for (var i = 0; i < lastElements.length; i++) {
|
|
|
+ sum = sum + lastElements[i];
|
|
|
+ }
|
|
|
+
|
|
|
+ return Math.ceil(sum / number);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Sets the value for the given attribute from the `data-` attribute with the same suffix
|
|
|
+ * ie: data-srcset ==> srcset | data-src ==> src
|
|
|
+ */
|
|
|
+
|
|
|
+ function setSrc(element, attribute) {
|
|
|
+ element.setAttribute(attribute, getAttr(element, 'data-' + attribute));
|
|
|
+ element.removeAttribute('data-' + attribute);
|
|
|
+ }
|
|
|
+ function getParentsUntil(item, topParentSelector) {
|
|
|
+ var parents = [item];
|
|
|
+
|
|
|
+ do {
|
|
|
+ item = item.parentNode;
|
|
|
+ parents.push(item);
|
|
|
+ } while (!matches(item, topParentSelector));
|
|
|
+
|
|
|
+ return parents;
|
|
|
+ }
|
|
|
+ function isInsideInput() {
|
|
|
+ var activeElement = doc.activeElement;
|
|
|
+ return matches(activeElement, 'textarea') || matches(activeElement, 'input') || matches(activeElement, 'select') || getAttr(activeElement, 'contentEditable') == "true" || getAttr(activeElement, 'contentEditable') == '';
|
|
|
+ } //utils are public, so we can use it wherever we want
|
|
|
+ // @ts-ignore
|
|
|
+
|
|
|
+ window["fp_utils"] = {
|
|
|
+ "$": $,
|
|
|
+ "deepExtend": deepExtend,
|
|
|
+ "hasClass": hasClass,
|
|
|
+ "getWindowHeight": getWindowHeight,
|
|
|
+ "css": css,
|
|
|
+ "prev": prev,
|
|
|
+ "next": next,
|
|
|
+ "last": last,
|
|
|
+ "index": index,
|
|
|
+ "getList": getList,
|
|
|
+ "hide": hide,
|
|
|
+ "show": show,
|
|
|
+ "isArrayOrList": isArrayOrList,
|
|
|
+ "addClass": addClass,
|
|
|
+ "removeClass": removeClass,
|
|
|
+ "appendTo": appendTo,
|
|
|
+ "wrap": wrap,
|
|
|
+ "wrapAll": wrapAll,
|
|
|
+ "unwrap": unwrap,
|
|
|
+ "closest": closest,
|
|
|
+ "after": after,
|
|
|
+ "before": before,
|
|
|
+ "insertBefore": insertBefore,
|
|
|
+ "getScrollTop": getScrollTop,
|
|
|
+ "siblings": siblings,
|
|
|
+ "preventDefault": preventDefault,
|
|
|
+ "isFunction": isFunction,
|
|
|
+ "trigger": trigger,
|
|
|
+ "matches": matches,
|
|
|
+ "toggle": toggle,
|
|
|
+ "createElementFromHTML": createElementFromHTML,
|
|
|
+ "remove": remove,
|
|
|
+ // "filter": filter,
|
|
|
+ "untilAll": untilAll,
|
|
|
+ "nextAll": nextAll,
|
|
|
+ "prevAll": prevAll,
|
|
|
+ "showError": showError
|
|
|
+ };
|
|
|
+
|
|
|
+ var utils = /*#__PURE__*/Object.freeze({
|
|
|
+ __proto__: null,
|
|
|
+ showError: showError,
|
|
|
+ isVisible: isVisible,
|
|
|
+ getVisible: getVisible,
|
|
|
+ $: $,
|
|
|
+ deepExtend: deepExtend,
|
|
|
+ hasClass: hasClass,
|
|
|
+ getWindowHeight: getWindowHeight,
|
|
|
+ getWindowWidth: getWindowWidth,
|
|
|
+ css: css,
|
|
|
+ prev: prev,
|
|
|
+ next: next,
|
|
|
+ last: last,
|
|
|
+ index: index,
|
|
|
+ getList: getList,
|
|
|
+ hide: hide,
|
|
|
+ show: show,
|
|
|
+ isArrayOrList: isArrayOrList,
|
|
|
+ addClass: addClass,
|
|
|
+ removeClass: removeClass,
|
|
|
+ appendTo: appendTo,
|
|
|
+ wrap: wrap,
|
|
|
+ wrapAll: wrapAll,
|
|
|
+ wrapInner: wrapInner,
|
|
|
+ unwrap: unwrap,
|
|
|
+ closest: closest,
|
|
|
+ after: after,
|
|
|
+ before: before,
|
|
|
+ insertBefore: insertBefore,
|
|
|
+ getScrollTop: getScrollTop,
|
|
|
+ siblings: siblings,
|
|
|
+ preventDefault: preventDefault,
|
|
|
+ getAttr: getAttr,
|
|
|
+ docAddEvent: docAddEvent,
|
|
|
+ windowAddEvent: windowAddEvent,
|
|
|
+ docRemoveEvent: docRemoveEvent,
|
|
|
+ windowRemoveEvent: windowRemoveEvent,
|
|
|
+ isFunction: isFunction,
|
|
|
+ trigger: trigger,
|
|
|
+ matches: matches,
|
|
|
+ toggle: toggle,
|
|
|
+ createElementFromHTML: createElementFromHTML,
|
|
|
+ remove: remove,
|
|
|
+ untilAll: untilAll,
|
|
|
+ nextAll: nextAll,
|
|
|
+ prevAll: prevAll,
|
|
|
+ toArray: toArray,
|
|
|
+ getLast: getLast,
|
|
|
+ getAverage: getAverage,
|
|
|
+ setSrc: setSrc,
|
|
|
+ getParentsUntil: getParentsUntil,
|
|
|
+ isInsideInput: isInsideInput
|
|
|
+ });
|
|
|
+
|
|
|
+ function _typeof(obj) {
|
|
|
+ "@babel/helpers - typeof";
|
|
|
+
|
|
|
+ if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
|
|
|
+ _typeof = function (obj) {
|
|
|
+ return typeof obj;
|
|
|
+ };
|
|
|
+ } else {
|
|
|
+ _typeof = function (obj) {
|
|
|
+ return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ return _typeof(obj);
|
|
|
+ }
|
|
|
+
|
|
|
+ var EventEmitter = {
|
|
|
+ events: {},
|
|
|
+ on: function on(event, listener) {
|
|
|
+ var _this = this;
|
|
|
+
|
|
|
+ if (_typeof(this.events[event]) !== 'object') {
|
|
|
+ this.events[event] = [];
|
|
|
+ }
|
|
|
+
|
|
|
+ this.events[event].push(listener);
|
|
|
+ return function () {
|
|
|
+ return _this.removeListener(event, listener);
|
|
|
+ };
|
|
|
+ },
|
|
|
+ removeListener: function removeListener(event, listener) {
|
|
|
+ if (_typeof(this.events[event]) === 'object') {
|
|
|
+ var idx = this.events[event].indexOf(listener);
|
|
|
+
|
|
|
+ if (idx > -1) {
|
|
|
+ this.events[event].splice(idx, 1);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ emit: function emit(event) {
|
|
|
+ var _this2 = this;
|
|
|
+
|
|
|
+ for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
|
+ args[_key - 1] = arguments[_key];
|
|
|
+ }
|
|
|
+
|
|
|
+ if (_typeof(this.events[event]) === 'object') {
|
|
|
+ this.events[event].forEach(function (listener) {
|
|
|
+ return listener.apply(_this2, args);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ },
|
|
|
+ once: function once(event, listener) {
|
|
|
+ var _this3 = this;
|
|
|
+
|
|
|
+ var remove = this.on(event, function () {
|
|
|
+ remove();
|
|
|
+
|
|
|
+ for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
|
|
+ args[_key2] = arguments[_key2];
|
|
|
+ }
|
|
|
+
|
|
|
+ listener.apply(_this3, args);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ var state = {
|
|
|
+ numSections: 0,
|
|
|
+ numSlides: 0,
|
|
|
+ slides: [],
|
|
|
+ sections: [],
|
|
|
+ activeSection: null,
|
|
|
+ scrollTrigger: null,
|
|
|
+ isBeyondFullpage: false,
|
|
|
+ aboutToScrollToFullPage: false,
|
|
|
+ slideMoving: false,
|
|
|
+ isResizing: false,
|
|
|
+ isScrolling: false,
|
|
|
+ lastScrolledDestiny: undefined,
|
|
|
+ lastScrolledSlide: undefined,
|
|
|
+ activeAnimation: false,
|
|
|
+ canScroll: true,
|
|
|
+ touchDirection: 'none',
|
|
|
+ wheelDirection: 'none',
|
|
|
+ isGrabbing: false,
|
|
|
+ isUsingWheel: false,
|
|
|
+ isWindowFocused: true,
|
|
|
+ previousDestTop: 0,
|
|
|
+ windowsHeight: getWindowHeight(),
|
|
|
+ isDoingContinousVertical: false,
|
|
|
+ timeouts: {},
|
|
|
+ scrollY: 0,
|
|
|
+ scrollX: 0
|
|
|
+ }; // @ts-ignore
|
|
|
+
|
|
|
+ win.state = state;
|
|
|
+ function setState(props) {
|
|
|
+ Object.assign(state, props);
|
|
|
+ }
|
|
|
+ function getState() {
|
|
|
+ return state;
|
|
|
+ }
|
|
|
+ function getActivePanel() {
|
|
|
+ return state.activeSection && state.activeSection.activeSlide ? state.activeSection.activeSlide : state.activeSection;
|
|
|
+ }
|
|
|
+
|
|
|
+ var events = {
|
|
|
+ onAfterRenderNoAnchor: 'onAfterRenderNoAnchor',
|
|
|
+ onClickOrTouch: 'onClickOrTouch',
|
|
|
+ moveSlideLeft: 'moveSlideLeft',
|
|
|
+ moveSlideRight: 'moveSlideRight',
|
|
|
+ onInitialise: 'onInitialise',
|
|
|
+ beforeInit: 'beforeInit',
|
|
|
+ bindEvents: 'bindEvents',
|
|
|
+ onDestroy: 'onDestroy',
|
|
|
+ contentChanged: 'contentChanged',
|
|
|
+ onScrollOverflowScrolled: 'onScrollOverflowScrolled',
|
|
|
+ onScrollPageAndSlide: 'onScrollPageAndSlide',
|
|
|
+ onKeyDown: 'onKeyDown',
|
|
|
+ onMenuClick: 'onMenuClick',
|
|
|
+ scrollPage: 'scrollPage',
|
|
|
+ landscapeScroll: 'landscapeScroll',
|
|
|
+ scrollBeyondFullpage: 'scrollBeyondFullpage',
|
|
|
+ onPerformMovement: 'onPerformMovement',
|
|
|
+ onSlideLeave: 'onSlideLeave',
|
|
|
+ onLeave: 'onLeave',
|
|
|
+ afterSectionLoads: 'afterSectionLoads',
|
|
|
+ afterSlideLoads: 'afterSlideLoads'
|
|
|
+ };
|
|
|
+
|
|
|
+ EventEmitter.on(events.bindEvents, bindEvents$c);
|
|
|
+
|
|
|
+ function bindEvents$c() {
|
|
|
+ //Scrolls to the section when clicking the navigation bullet
|
|
|
+ //simulating the jQuery .on('click') event using delegation
|
|
|
+ ['click', 'touchstart'].forEach(function (eventName) {
|
|
|
+ docAddEvent(eventName, delegatedEvents);
|
|
|
+ });
|
|
|
+ windowAddEvent('focus', focusHandler);
|
|
|
+ internalEvents();
|
|
|
+ }
|
|
|
+
|
|
|
+ function internalEvents() {
|
|
|
+ EventEmitter.on(events.onDestroy, onDestroy$9);
|
|
|
+ }
|
|
|
+
|
|
|
+ function delegatedEvents(e) {
|
|
|
+ EventEmitter.emit(events.onClickOrTouch, {
|
|
|
+ e: e,
|
|
|
+ target: e.target
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ function onDestroy$9() {
|
|
|
+ ['click', 'touchstart'].forEach(function (eventName) {
|
|
|
+ docRemoveEvent(eventName, delegatedEvents);
|
|
|
+ });
|
|
|
+ } // changing isWindowFocused to true on focus event
|
|
|
+
|
|
|
+
|
|
|
+ function focusHandler() {
|
|
|
+ setState({
|
|
|
+ isWindowFocused: true
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ // keeping central set of classnames and selectors
|
|
|
+ var WRAPPER = 'fullpage-wrapper';
|
|
|
+ var WRAPPER_SEL = '.' + WRAPPER; // slimscroll
|
|
|
+
|
|
|
+ var SCROLLABLE = 'fp-scrollable';
|
|
|
+
|
|
|
+ var RESPONSIVE = 'fp-responsive';
|
|
|
+ var NO_TRANSITION = 'fp-notransition';
|
|
|
+ var DESTROYED = 'fp-destroyed';
|
|
|
+ var ENABLED = 'fp-enabled';
|
|
|
+ var VIEWING_PREFIX = 'fp-viewing';
|
|
|
+ var ACTIVE = 'active';
|
|
|
+ var ACTIVE_SEL = '.' + ACTIVE;
|
|
|
+ var COMPLETELY = 'fp-completely';
|
|
|
+ var COMPLETELY_SEL = '.' + COMPLETELY; // section
|
|
|
+
|
|
|
+ var SECTION_DEFAULT_SEL = '.section';
|
|
|
+ var SECTION = 'fp-section';
|
|
|
+ var SECTION_SEL = '.' + SECTION;
|
|
|
+ var SECTION_ACTIVE_SEL = SECTION_SEL + ACTIVE_SEL;
|
|
|
+ var TABLE_CELL = 'fp-tableCell';
|
|
|
+ var TABLE_CELL_SEL = '.' + TABLE_CELL;
|
|
|
+ var AUTO_HEIGHT = 'fp-auto-height';
|
|
|
+ var AUTO_HEIGHT_SEL = '.' + AUTO_HEIGHT;
|
|
|
+ var AUTO_HEIGHT_RESPONSIVE = 'fp-auto-height-responsive';
|
|
|
+ var AUTO_HEIGHT_RESPONSIVE_SEL = '.' + AUTO_HEIGHT_RESPONSIVE;
|
|
|
+ var NORMAL_SCROLL = 'fp-normal-scroll';
|
|
|
+
|
|
|
+ var SECTION_NAV = 'fp-nav';
|
|
|
+ var SECTION_NAV_SEL = '#' + SECTION_NAV;
|
|
|
+ var SECTION_NAV_TOOLTIP = 'fp-tooltip';
|
|
|
+ var SECTION_NAV_TOOLTIP_SEL = '.' + SECTION_NAV_TOOLTIP;
|
|
|
+ var SHOW_ACTIVE_TOOLTIP = 'fp-show-active'; // slide
|
|
|
+
|
|
|
+ var SLIDE_DEFAULT_SEL = '.slide';
|
|
|
+ var SLIDE = 'fp-slide';
|
|
|
+ var SLIDE_SEL = '.' + SLIDE;
|
|
|
+ var SLIDE_ACTIVE_SEL = SLIDE_SEL + ACTIVE_SEL;
|
|
|
+ var SLIDES_WRAPPER = 'fp-slides';
|
|
|
+ var SLIDES_WRAPPER_SEL = '.' + SLIDES_WRAPPER;
|
|
|
+ var SLIDES_CONTAINER = 'fp-slidesContainer';
|
|
|
+ var SLIDES_CONTAINER_SEL = '.' + SLIDES_CONTAINER;
|
|
|
+ var TABLE = 'fp-table';
|
|
|
+ var OVERFLOW = 'fp-overflow';
|
|
|
+ var OVERFLOW_SEL = '.' + OVERFLOW;
|
|
|
+ var IS_OVERFLOW = 'fp-is-overflow'; // slide nav
|
|
|
+
|
|
|
+ var SLIDES_NAV = 'fp-slidesNav';
|
|
|
+ var SLIDES_NAV_SEL = '.' + SLIDES_NAV;
|
|
|
+ var SLIDES_NAV_LINK_SEL = SLIDES_NAV_SEL + ' a';
|
|
|
+ var SLIDES_STYLED_ARROW = 'fp-arrow';
|
|
|
+ var SLIDES_ARROW = 'fp-controlArrow';
|
|
|
+ var SLIDES_ARROW_SEL = '.' + SLIDES_ARROW;
|
|
|
+ var SLIDES_PREV = 'fp-prev';
|
|
|
+ var SLIDES_PREV_SEL = '.' + SLIDES_PREV;
|
|
|
+ var SLIDES_ARROW_PREV_SEL = SLIDES_ARROW_SEL + SLIDES_PREV_SEL;
|
|
|
+ var SLIDES_NEXT = 'fp-next';
|
|
|
+ var SLIDES_NEXT_SEL = '.' + SLIDES_NEXT;
|
|
|
+ var SLIDES_ARROW_NEXT_SEL = SLIDES_ARROW_SEL + SLIDES_NEXT_SEL;
|
|
|
+
|
|
|
+ var defaultOptions = {
|
|
|
+ //navigation
|
|
|
+ menu: false,
|
|
|
+ anchors: [],
|
|
|
+ lockAnchors: false,
|
|
|
+ navigation: false,
|
|
|
+ navigationPosition: 'right',
|
|
|
+ navigationTooltips: [],
|
|
|
+ showActiveTooltip: false,
|
|
|
+ slidesNavigation: false,
|
|
|
+ slidesNavPosition: 'bottom',
|
|
|
+ scrollBar: false,
|
|
|
+ hybrid: false,
|
|
|
+ licenseKey: '',
|
|
|
+ credits: {
|
|
|
+ "enabled": true,
|
|
|
+ "label": 'Made with fullPage.js',
|
|
|
+ "position": 'right'
|
|
|
+ },
|
|
|
+ //scrolling
|
|
|
+ css3: true,
|
|
|
+ scrollingSpeed: 700,
|
|
|
+ autoScrolling: true,
|
|
|
+ fitToSection: true,
|
|
|
+ fitToSectionDelay: 600,
|
|
|
+ easing: 'easeInOutCubic',
|
|
|
+ easingcss3: 'ease',
|
|
|
+ loopBottom: false,
|
|
|
+ loopTop: false,
|
|
|
+ loopHorizontal: true,
|
|
|
+ continuousVertical: false,
|
|
|
+ continuousHorizontal: false,
|
|
|
+ scrollHorizontally: false,
|
|
|
+ interlockedSlides: false,
|
|
|
+ dragAndMove: false,
|
|
|
+ offsetSections: false,
|
|
|
+ resetSliders: false,
|
|
|
+ fadingEffect: false,
|
|
|
+ normalScrollElements: null,
|
|
|
+ scrollOverflow: true,
|
|
|
+ scrollOverflowReset: false,
|
|
|
+ touchSensitivity: 5,
|
|
|
+ touchWrapper: null,
|
|
|
+ bigSectionsDestination: null,
|
|
|
+ //Accessibility
|
|
|
+ keyboardScrolling: true,
|
|
|
+ animateAnchor: true,
|
|
|
+ recordHistory: true,
|
|
|
+ allowCorrectDirection: false,
|
|
|
+ //design
|
|
|
+ scrollOverflowMacStyle: true,
|
|
|
+ controlArrows: true,
|
|
|
+ controlArrowsHTML: ['<div class="' + SLIDES_STYLED_ARROW + '"></div>', '<div class="' + SLIDES_STYLED_ARROW + '"></div>'],
|
|
|
+ controlArrowColor: '#fff',
|
|
|
+ verticalCentered: true,
|
|
|
+ sectionsColor: [],
|
|
|
+ paddingTop: 0,
|
|
|
+ paddingBottom: 0,
|
|
|
+ fixedElements: null,
|
|
|
+ responsive: 0,
|
|
|
+ //backwards compabitility with responsiveWiddth
|
|
|
+ responsiveWidth: 0,
|
|
|
+ responsiveHeight: 0,
|
|
|
+ responsiveSlides: false,
|
|
|
+ parallax: false,
|
|
|
+ parallaxOptions: {
|
|
|
+ type: 'reveal',
|
|
|
+ percentage: 62,
|
|
|
+ property: 'translate'
|
|
|
+ },
|
|
|
+ cards: false,
|
|
|
+ cardsOptions: {
|
|
|
+ perspective: 100,
|
|
|
+ fadeContent: true,
|
|
|
+ fadeBackground: true
|
|
|
+ },
|
|
|
+ //Custom selectors
|
|
|
+ sectionSelector: SECTION_DEFAULT_SEL,
|
|
|
+ slideSelector: SLIDE_DEFAULT_SEL,
|
|
|
+ //events
|
|
|
+ afterLoad: null,
|
|
|
+ beforeLeave: null,
|
|
|
+ onLeave: null,
|
|
|
+ afterRender: null,
|
|
|
+ afterResize: null,
|
|
|
+ afterReBuild: null,
|
|
|
+ afterSlideLoad: null,
|
|
|
+ onSlideLeave: null,
|
|
|
+ afterResponsive: null,
|
|
|
+ onScrollOverflow: null,
|
|
|
+ lazyLoading: true,
|
|
|
+ observer: true,
|
|
|
+ scrollBeyondFullpage: true
|
|
|
+ };
|
|
|
+
|
|
|
+ var container = null;
|
|
|
+ var g_initialAnchorsInDom = false;
|
|
|
+ var originals = deepExtend({}, defaultOptions); //deep copy
|
|
|
+
|
|
|
+ var g_options = null;
|
|
|
+ function getInitialAnchorsInDom() {
|
|
|
+ return g_initialAnchorsInDom;
|
|
|
+ }
|
|
|
+ function setContainer(value) {
|
|
|
+ container = value;
|
|
|
+ }
|
|
|
+ function getContainer(value) {
|
|
|
+ return container;
|
|
|
+ }
|
|
|
+ function getOptions() {
|
|
|
+ return g_options || defaultOptions;
|
|
|
+ }
|
|
|
+ function setOptions(options) {
|
|
|
+ g_options = deepExtend({}, defaultOptions, options);
|
|
|
+ originals = Object.assign({}, g_options);
|
|
|
+ }
|
|
|
+ function getOriginals() {
|
|
|
+ return originals;
|
|
|
+ }
|
|
|
+ function setOption(name, value) {
|
|
|
+ defaultOptions[name] = value;
|
|
|
+ }
|
|
|
+ /*
|
|
|
+ * Sets the state for a variable with multiple states (original, and temporal)
|
|
|
+ * Some variables such as `autoScrolling` or `recordHistory` might change automatically its state when using `responsive` or `autoScrolling:false`.
|
|
|
+ * This function is used to keep track of both states, the original and the temporal one.
|
|
|
+ * If type is not 'internal', then we assume the user is globally changing the variable.
|
|
|
+ */
|
|
|
+
|
|
|
+ function setVariableState(variable, value, type) {
|
|
|
+ g_options[variable] = value;
|
|
|
+
|
|
|
+ if (type !== 'internal') {
|
|
|
+ originals[variable] = value;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Setting options from DOM elements if they are not provided.
|
|
|
+ */
|
|
|
+
|
|
|
+ function setOptionsFromDOM() {
|
|
|
+ //no anchors option? Checking for them in the DOM attributes
|
|
|
+ if (!getOptions().anchors.length) {
|
|
|
+ var anchorsAttribute = '[data-anchor]';
|
|
|
+ var anchors = $(getOptions().sectionSelector.split(',').join(anchorsAttribute + ',') + anchorsAttribute, container);
|
|
|
+
|
|
|
+ if (anchors.length && anchors.length === $(getOptions().sectionSelector, container).length) {
|
|
|
+ g_initialAnchorsInDom = true;
|
|
|
+ anchors.forEach(function (item) {
|
|
|
+ getOptions().anchors.push(getAttr(item, 'data-anchor').toString());
|
|
|
+ });
|
|
|
+ }
|
|
|
+ } //no tooltips option? Checking for them in the DOM attributes
|
|
|
+
|
|
|
+
|
|
|
+ if (!getOptions().navigationTooltips.length) {
|
|
|
+ var tooltipsAttribute = '[data-tooltip]';
|
|
|
+ var tooltips = $(getOptions().sectionSelector.split(',').join(tooltipsAttribute + ',') + tooltipsAttribute, container);
|
|
|
+
|
|
|
+ if (tooltips.length) {
|
|
|
+ tooltips.forEach(function (item) {
|
|
|
+ getOptions().navigationTooltips.push(getAttr(item, 'data-tooltip').toString());
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var plainItem = function plainItem(panel) {
|
|
|
+ this.anchor = panel.anchor;
|
|
|
+ this.item = panel.item;
|
|
|
+ this.index = panel.index();
|
|
|
+ this.isLast = this.index === panel.item.parentElement.querySelectorAll(panel.selector).length - 1;
|
|
|
+ this.isFirst = !this.index;
|
|
|
+ this.isActive = panel.isActive;
|
|
|
+ };
|
|
|
+ /**
|
|
|
+ * Item. Slide or Section objects share the same properties.
|
|
|
+ */
|
|
|
+
|
|
|
+ var Item = function Item(el, selector) {
|
|
|
+ this.parent = this.parent || null;
|
|
|
+ this.selector = selector;
|
|
|
+ this.anchor = getAttr(el, 'data-anchor') || getOptions().anchors[index(el, getOptions().sectionSelector)];
|
|
|
+ this.item = el;
|
|
|
+ this.isVisible = isVisible(el);
|
|
|
+ this.isActive = hasClass(el, ACTIVE);
|
|
|
+ this.hasScroll = hasClass(el, OVERFLOW) || $(OVERFLOW_SEL, el)[0] != null;
|
|
|
+ this.isSection = selector === getOptions().sectionSelector;
|
|
|
+ this.container = closest(el, SLIDES_CONTAINER_SEL) || closest(el, WRAPPER_SEL);
|
|
|
+
|
|
|
+ this.index = function () {
|
|
|
+ return this.siblings().indexOf(this);
|
|
|
+ };
|
|
|
+ };
|
|
|
+
|
|
|
+ Item.prototype.siblings = function () {
|
|
|
+ if (this.isSection) {
|
|
|
+ if (this.isVisible) {
|
|
|
+ return state.sections;
|
|
|
+ } else {
|
|
|
+ return state.sectionsIncludingHidden;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return this.parent ? this.parent.slides : 0;
|
|
|
+ };
|
|
|
+
|
|
|
+ Item.prototype.prev = function () {
|
|
|
+ var siblings = this.siblings();
|
|
|
+ var currentIndex = this.isSection ? siblings.indexOf(this) : this.parent.slides.indexOf(this);
|
|
|
+ var prevIndex = currentIndex - 1;
|
|
|
+
|
|
|
+ if (prevIndex >= 0) {
|
|
|
+ return siblings[prevIndex];
|
|
|
+ }
|
|
|
+
|
|
|
+ return null;
|
|
|
+ };
|
|
|
+
|
|
|
+ Item.prototype.next = function () {
|
|
|
+ var siblings = this.siblings();
|
|
|
+ var currentIndex = this.isSection ? siblings.indexOf(this) : this.parent.slides.indexOf(this);
|
|
|
+ var nextIndex = currentIndex + 1;
|
|
|
+
|
|
|
+ if (nextIndex < siblings.length) {
|
|
|
+ return siblings[nextIndex];
|
|
|
+ }
|
|
|
+
|
|
|
+ return null;
|
|
|
+ };
|
|
|
+
|
|
|
+ Item.prototype["prevPanel"] = function () {
|
|
|
+ return this.prev() || (this.parent ? this.parent.prev() : null);
|
|
|
+ };
|
|
|
+
|
|
|
+ Item.prototype["nextPanel"] = function () {
|
|
|
+ return this.next() || (this.parent ? this.parent.next() : null);
|
|
|
+ };
|
|
|
+
|
|
|
+ Item.prototype.getSiblings = function () {
|
|
|
+ if (this.isSection) {
|
|
|
+ return state.sections;
|
|
|
+ }
|
|
|
+
|
|
|
+ return state.panels;
|
|
|
+ };
|
|
|
+
|
|
|
+ function getNodes(panels) {
|
|
|
+ return panels.map(function (panel) {
|
|
|
+ return panel.item;
|
|
|
+ });
|
|
|
+ }
|
|
|
+ function getPanelByElement(panels, el) {
|
|
|
+ return panels.find(function (panel) {
|
|
|
+ return panel.item === el;
|
|
|
+ });
|
|
|
+ }
|
|
|
+ var Section = function Section(el) {
|
|
|
+ plainItem.call(this, el);
|
|
|
+ };
|
|
|
+ var Slide = function Slide(el) {
|
|
|
+ plainItem.call(this, el);
|
|
|
+ };
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Gets the active slide (or section) for the given section
|
|
|
+ */
|
|
|
+
|
|
|
+ function getSlideOrSection(destiny) {
|
|
|
+ var slide = $(SLIDE_ACTIVE_SEL, destiny);
|
|
|
+
|
|
|
+ if (slide.length) {
|
|
|
+ destiny = slide[0];
|
|
|
+ }
|
|
|
+
|
|
|
+ return destiny;
|
|
|
+ }
|
|
|
+ function getSlideOrSectionPanel(panel) {
|
|
|
+ if (!panel) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ return panel.activeSlide ? panel.activeSlide : panel;
|
|
|
+ }
|
|
|
+ function isFullPageAbove() {
|
|
|
+ return getContainer().getBoundingClientRect().bottom >= 0;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets the scrolling settings depending on the plugin autoScrolling option
|
|
|
+ */
|
|
|
+
|
|
|
+ function getScrollSettings(top) {
|
|
|
+ var options = getOptions();
|
|
|
+ var position;
|
|
|
+ var element; //top property animation
|
|
|
+
|
|
|
+ if (options.autoScrolling && !options.scrollBar) {
|
|
|
+ position = -top;
|
|
|
+ element = $(WRAPPER_SEL)[0];
|
|
|
+ } //window real scrolling
|
|
|
+ else {
|
|
|
+ position = top;
|
|
|
+ element = window;
|
|
|
+ }
|
|
|
+
|
|
|
+ return {
|
|
|
+ options: position,
|
|
|
+ element: element
|
|
|
+ };
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Scrolls the page / slider the given number of pixels.
|
|
|
+ * It will do it one or another way dependiong on the library's config.
|
|
|
+ */
|
|
|
+
|
|
|
+ function setScrolling(element, val) {
|
|
|
+ if (!getOptions().autoScrolling || getOptions().scrollBar || element.self != window && hasClass(element, SLIDES_WRAPPER)) {
|
|
|
+ //scrolling horizontally through the slides?
|
|
|
+ if (element.self != window && hasClass(element, SLIDES_WRAPPER)) {
|
|
|
+ element.scrollLeft = val;
|
|
|
+ } //vertical scroll
|
|
|
+ else {
|
|
|
+ element.scrollTo(0, val);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ element.style.top = val + 'px';
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Adds transition animations for the given element
|
|
|
+ */
|
|
|
+
|
|
|
+ function addAnimation(element) {
|
|
|
+ var transition = 'transform ' + getOptions().scrollingSpeed + 'ms ' + getOptions().easingcss3;
|
|
|
+ removeClass(element, NO_TRANSITION);
|
|
|
+ return css(element, {
|
|
|
+ '-webkit-transition': transition,
|
|
|
+ 'transition': transition
|
|
|
+ });
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Retuns `up` or `down` depending on the scrolling movement to reach its destination
|
|
|
+ * from the current section.
|
|
|
+ */
|
|
|
+
|
|
|
+ function getYmovement(activeSection, destiny) {
|
|
|
+ var fromIndex = activeSection.index();
|
|
|
+ var toIndex = index(destiny, SECTION_SEL);
|
|
|
+
|
|
|
+ if (fromIndex == toIndex) {
|
|
|
+ return 'none';
|
|
|
+ }
|
|
|
+
|
|
|
+ if (fromIndex > toIndex) {
|
|
|
+ return 'up';
|
|
|
+ }
|
|
|
+
|
|
|
+ return 'down';
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Remove transition animations for the given element
|
|
|
+ */
|
|
|
+
|
|
|
+ function removeAnimation(element) {
|
|
|
+ return addClass(element, NO_TRANSITION);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Returns the cross-browser transform string.
|
|
|
+ */
|
|
|
+
|
|
|
+ function getTransforms(translate3d) {
|
|
|
+ return {
|
|
|
+ '-webkit-transform': translate3d,
|
|
|
+ '-moz-transform': translate3d,
|
|
|
+ '-ms-transform': translate3d,
|
|
|
+ 'transform': translate3d
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ var silentScrollId;
|
|
|
+ /**
|
|
|
+ * Adds a css3 transform property to the container class with or without animation depending on the animated param.
|
|
|
+ */
|
|
|
+
|
|
|
+ function transformContainer(translate3d, animated) {
|
|
|
+ if (animated) {
|
|
|
+ addAnimation(getContainer());
|
|
|
+ } else {
|
|
|
+ removeAnimation(getContainer());
|
|
|
+ }
|
|
|
+
|
|
|
+ clearTimeout(silentScrollId);
|
|
|
+ css(getContainer(), getTransforms(translate3d));
|
|
|
+ FP.test.translate3d = translate3d; //syncronously removing the class after the animation has been applied.
|
|
|
+
|
|
|
+ silentScrollId = setTimeout(function () {
|
|
|
+ removeClass(getContainer(), NO_TRANSITION);
|
|
|
+ }, 10);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Scrolls silently (with no animation) the page to the given Y position.
|
|
|
+ */
|
|
|
+
|
|
|
+ function silentScroll(top) {
|
|
|
+ // The first section can have a negative value in iOS 10. Not quite sure why: -0.0142822265625
|
|
|
+ // that's why we round it to 0.
|
|
|
+ var roundedTop = Math.round(top);
|
|
|
+
|
|
|
+ if (getOptions().css3 && getOptions().autoScrolling && !getOptions().scrollBar) {
|
|
|
+ var translate3d = 'translate3d(0px, -' + roundedTop + 'px, 0px)';
|
|
|
+ transformContainer(translate3d, false);
|
|
|
+ } else if (getOptions().autoScrolling && !getOptions().scrollBar) {
|
|
|
+ css(getContainer(), {
|
|
|
+ 'top': -roundedTop + 'px'
|
|
|
+ });
|
|
|
+ FP.test.top = -roundedTop + 'px';
|
|
|
+ } else {
|
|
|
+ var scrollSettings = getScrollSettings(roundedTop);
|
|
|
+ setScrolling(scrollSettings.element, scrollSettings.options);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ FP.setScrollingSpeed = setScrollingSpeed;
|
|
|
+ /**
|
|
|
+ * Defines the scrolling speed
|
|
|
+ */
|
|
|
+
|
|
|
+ function setScrollingSpeed(value, type) {
|
|
|
+ setVariableState('scrollingSpeed', value, type);
|
|
|
+ }
|
|
|
+
|
|
|
+ var $body = null;
|
|
|
+ var $html = null;
|
|
|
+ var $htmlBody = null; // caching common elements
|
|
|
+
|
|
|
+ function setCache() {
|
|
|
+ $body = $('body')[0];
|
|
|
+ $html = $('html')[0];
|
|
|
+ $htmlBody = $('html, body');
|
|
|
+ }
|
|
|
+
|
|
|
+ //@ts-check
|
|
|
+
|
|
|
+ var _g_animateScroll;
|
|
|
+ /**
|
|
|
+ * Simulates the animated scrollTop of jQuery. Used when css3:false or scrollBar:true or autoScrolling:false
|
|
|
+ * http://stackoverflow.com/a/16136789/1081396
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function scrollTo(element, to, duration, callback) {
|
|
|
+ var start = getScrolledPosition(element);
|
|
|
+ var change = to - start;
|
|
|
+ var isCallbackFired = false;
|
|
|
+ var startTime;
|
|
|
+ var wasAnimationActive = state.activeAnimation;
|
|
|
+ setState({
|
|
|
+ activeAnimation: true
|
|
|
+ }); // Cancelling any possible previous animations (io: clicking on nav dots very fast)
|
|
|
+
|
|
|
+ if (_g_animateScroll) {
|
|
|
+ window.cancelAnimationFrame(_g_animateScroll);
|
|
|
+ }
|
|
|
+
|
|
|
+ _g_animateScroll = function g_animateScroll(timestamp) {
|
|
|
+ if (!startTime) {
|
|
|
+ startTime = timestamp;
|
|
|
+ }
|
|
|
+
|
|
|
+ var currentTime = Math.floor(timestamp - startTime);
|
|
|
+
|
|
|
+ if (state.activeAnimation) {
|
|
|
+ //in order to stope it from other function whenever we want
|
|
|
+ var val = to;
|
|
|
+
|
|
|
+ if (duration) {
|
|
|
+ // @ts-ignore
|
|
|
+ val = win.fp_easings[getOptions().easing](currentTime, start, change, duration);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (currentTime <= duration) {
|
|
|
+ setScrolling(element, val);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (currentTime < duration) {
|
|
|
+ window.requestAnimationFrame(_g_animateScroll);
|
|
|
+ } else if (typeof callback !== 'undefined' && !isCallbackFired) {
|
|
|
+ callback();
|
|
|
+ setState({
|
|
|
+ activeAnimation: false
|
|
|
+ });
|
|
|
+ isCallbackFired = true;
|
|
|
+ }
|
|
|
+ } else if (!isCallbackFired && !wasAnimationActive) {
|
|
|
+ callback();
|
|
|
+ setState({
|
|
|
+ activeAnimation: false
|
|
|
+ });
|
|
|
+ isCallbackFired = true;
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ window.requestAnimationFrame(_g_animateScroll);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Getting the position of the element to scroll when using jQuery animations
|
|
|
+ */
|
|
|
+
|
|
|
+ function getScrolledPosition(element) {
|
|
|
+ var position; //is not the window element and is a slide?
|
|
|
+
|
|
|
+ if (element.self != win && hasClass(element, SLIDES_WRAPPER)) {
|
|
|
+ position = element.scrollLeft;
|
|
|
+ } else if (!getOptions().autoScrolling || getOptions().scrollBar) {
|
|
|
+ position = getScrollTop();
|
|
|
+ } else {
|
|
|
+ position = element.offsetTop;
|
|
|
+ } //gets the top property of the wrapper
|
|
|
+
|
|
|
+
|
|
|
+ return position;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Makes sure to only create a Panel object if the element exist
|
|
|
+ */
|
|
|
+
|
|
|
+ function nullOrSection(el) {
|
|
|
+ if (el && !el.item) {
|
|
|
+ return new Section(new SectionPanel(el));
|
|
|
+ }
|
|
|
+
|
|
|
+ return el ? new Section(el) : null;
|
|
|
+ }
|
|
|
+
|
|
|
+ function nullOrSlide(el) {
|
|
|
+ return el ? new Slide(el) : null;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Dispatch events & callbacks
|
|
|
+ */
|
|
|
+
|
|
|
+ function fireCallback(eventName, v) {
|
|
|
+ var eventData = getEventData(eventName, v);
|
|
|
+ trigger(getContainer(), eventName, eventData);
|
|
|
+
|
|
|
+ if (getOptions()[eventName].apply(eventData[Object.keys(eventData)[0]], toArray(eventData)) === false) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets the event's data for the given event on the right format.
|
|
|
+ */
|
|
|
+
|
|
|
+ function getEventData(eventName, v) {
|
|
|
+ //using functions to run only the necessary bits within the object
|
|
|
+ var paramsPerEvent = {
|
|
|
+ afterRender: function afterRender() {
|
|
|
+ return {
|
|
|
+ section: nullOrSection(getState().activeSection),
|
|
|
+ slide: nullOrSlide(getState().activeSection.activeSlide)
|
|
|
+ };
|
|
|
+ },
|
|
|
+ onLeave: function onLeave() {
|
|
|
+ return {
|
|
|
+ origin: nullOrSection(v.items.origin),
|
|
|
+ destination: nullOrSection(v.items.destination),
|
|
|
+ direction: v.direction,
|
|
|
+ trigger: getState().scrollTrigger
|
|
|
+ };
|
|
|
+ },
|
|
|
+ afterLoad: function afterLoad() {
|
|
|
+ return paramsPerEvent.onLeave();
|
|
|
+ },
|
|
|
+ afterSlideLoad: function afterSlideLoad() {
|
|
|
+ return {
|
|
|
+ section: nullOrSection(v.items.section),
|
|
|
+ origin: nullOrSection(v.items.origin),
|
|
|
+ destination: nullOrSection(v.items.destination),
|
|
|
+ direction: v.direction,
|
|
|
+ trigger: getState().scrollTrigger
|
|
|
+ };
|
|
|
+ },
|
|
|
+ onSlideLeave: function onSlideLeave() {
|
|
|
+ return paramsPerEvent.afterSlideLoad();
|
|
|
+ },
|
|
|
+ beforeLeave: function beforeLeave() {
|
|
|
+ return paramsPerEvent.onLeave();
|
|
|
+ },
|
|
|
+ onScrollOverflow: function onScrollOverflow() {
|
|
|
+ return {
|
|
|
+ section: nullOrSection(getState().activeSection),
|
|
|
+ slide: nullOrSlide(getState().activeSection.activeSlide),
|
|
|
+ position: v.position,
|
|
|
+ direction: v.direction
|
|
|
+ };
|
|
|
+ }
|
|
|
+ };
|
|
|
+ return paramsPerEvent[eventName]();
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Plays video and audio elements.
|
|
|
+ */
|
|
|
+
|
|
|
+ function playMedia(destiny) {
|
|
|
+ var panel = getSlideOrSection(destiny); //playing HTML5 media elements
|
|
|
+
|
|
|
+ $('video, audio', panel).forEach(function (element) {
|
|
|
+ if (element.hasAttribute('data-autoplay') && typeof element.play === 'function') {
|
|
|
+ element.play();
|
|
|
+ }
|
|
|
+ }); //youtube videos
|
|
|
+
|
|
|
+ $('iframe[src*="youtube.com/embed/"]', panel).forEach(function (element) {
|
|
|
+ if (element.hasAttribute('data-autoplay')) {
|
|
|
+ playYoutube(element);
|
|
|
+ } //in case the URL was not loaded yet. On page load we need time for the new URL (with the API string) to load.
|
|
|
+
|
|
|
+
|
|
|
+ element.onload = function () {
|
|
|
+ if (element.hasAttribute('data-autoplay')) {
|
|
|
+ playYoutube(element);
|
|
|
+ }
|
|
|
+ };
|
|
|
+ });
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Plays a youtube video
|
|
|
+ */
|
|
|
+
|
|
|
+ function playYoutube(element) {
|
|
|
+ element.contentWindow.postMessage('{"event":"command","func":"playVideo","args":""}', '*');
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Stops video and audio elements.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function stopMedia(destiny) {
|
|
|
+ var panel = getSlideOrSection(destiny); //stopping HTML5 media elements
|
|
|
+
|
|
|
+ $('video, audio', panel).forEach(function (element) {
|
|
|
+ if (!element.hasAttribute('data-keepplaying') && typeof element.pause === 'function') {
|
|
|
+ element.pause();
|
|
|
+ }
|
|
|
+ }); //youtube videos
|
|
|
+
|
|
|
+ $('iframe[src*="youtube.com/embed/"]', panel).forEach(function (element) {
|
|
|
+ if (/youtube\.com\/embed\//.test(getAttr(element, 'src')) && !element.hasAttribute('data-keepplaying')) {
|
|
|
+ element.contentWindow.postMessage('{"event":"command","func":"pauseVideo","args":""}', '*');
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+ /*
|
|
|
+ * Enables the Youtube videos API so we can control their flow if necessary.
|
|
|
+ */
|
|
|
+
|
|
|
+ function enableYoutubeAPI() {
|
|
|
+ $('iframe[src*="youtube.com/embed/"]', getContainer()).forEach(function (item) {
|
|
|
+ addURLParam(item, 'enablejsapi=1');
|
|
|
+ });
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Adds a new parameter and its value to the `src` of a given element
|
|
|
+ */
|
|
|
+
|
|
|
+ function addURLParam(element, newParam) {
|
|
|
+ var originalSrc = getAttr(element, 'src');
|
|
|
+ element.setAttribute('src', originalSrc + getUrlParamSign(originalSrc) + newParam);
|
|
|
+ }
|
|
|
+ /*
|
|
|
+ * Returns the prefix sign to use for a new parameter in an existen URL.
|
|
|
+ *
|
|
|
+ * @return {String} ? | &
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function getUrlParamSign(url) {
|
|
|
+ return !/\?/.test(url) ? '?' : '&';
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Lazy loads image, video and audio elements.
|
|
|
+ */
|
|
|
+
|
|
|
+ function lazyLoad(destiny) {
|
|
|
+ if (!getOptions().lazyLoading) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ var panel = getSlideOrSection(destiny);
|
|
|
+ $('img[data-src], img[data-srcset], source[data-src], source[data-srcset], video[data-src], audio[data-src], iframe[data-src]', panel).forEach(function (element) {
|
|
|
+ ['src', 'srcset'].forEach(function (type) {
|
|
|
+ var attribute = getAttr(element, 'data-' + type);
|
|
|
+
|
|
|
+ if (attribute != null && attribute) {
|
|
|
+ setSrc(element, type);
|
|
|
+ element.addEventListener('load', function () {
|
|
|
+ });
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ if (matches(element, 'source')) {
|
|
|
+ var elementToPlay = closest(element, 'video, audio');
|
|
|
+
|
|
|
+ if (elementToPlay) {
|
|
|
+ elementToPlay.load();
|
|
|
+
|
|
|
+ elementToPlay.onloadeddata = function () {
|
|
|
+ };
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sets a class for the body of the page depending on the active section / slide
|
|
|
+ */
|
|
|
+
|
|
|
+ function setBodyClass() {
|
|
|
+ var section = getState().activeSection.item;
|
|
|
+ var slide = getState().activeSection.activeSlide;
|
|
|
+ var sectionAnchor = getAnchor(section);
|
|
|
+ var text = String(sectionAnchor);
|
|
|
+
|
|
|
+ if (slide) {
|
|
|
+ var slideAnchor = getAnchor(slide.item);
|
|
|
+ text = text + '-' + slideAnchor;
|
|
|
+ } //changing slash for dash to make it a valid CSS style
|
|
|
+
|
|
|
+
|
|
|
+ text = text.replace('/', '-').replace('#', ''); //removing previous anchor classes
|
|
|
+
|
|
|
+ var classRe = new RegExp('\\b\\s?' + VIEWING_PREFIX + '-[^\\s]+\\b', "g");
|
|
|
+ $body.className = $body.className.replace(classRe, ''); //adding the current anchor
|
|
|
+
|
|
|
+ addClass($body, VIEWING_PREFIX + '-' + text);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets the anchor for the given slide / section. Its index will be used if there's none.
|
|
|
+ */
|
|
|
+
|
|
|
+ function getAnchor(element) {
|
|
|
+ if (!element) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ var anchor = getAttr(element, 'data-anchor');
|
|
|
+ var elementIndex = index(element); //Slide without anchor link? We take the index instead.
|
|
|
+
|
|
|
+ if (anchor == null) {
|
|
|
+ anchor = elementIndex;
|
|
|
+ }
|
|
|
+
|
|
|
+ return anchor;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sets the state of the website depending on the active section/slide.
|
|
|
+ * It changes the URL hash when needed and updates the body class.
|
|
|
+ */
|
|
|
+
|
|
|
+ function setPageStatus(slideIndex, slideAnchor, anchorLink) {
|
|
|
+ var sectionHash = '';
|
|
|
+
|
|
|
+ if (getOptions().anchors.length && !getOptions().lockAnchors) {
|
|
|
+ //isn't it the first slide?
|
|
|
+ if (slideIndex) {
|
|
|
+ if (anchorLink != null) {
|
|
|
+ sectionHash = anchorLink;
|
|
|
+ } //slide without anchor link? We take the index instead.
|
|
|
+
|
|
|
+
|
|
|
+ if (slideAnchor == null) {
|
|
|
+ slideAnchor = slideIndex;
|
|
|
+ }
|
|
|
+
|
|
|
+ setState({
|
|
|
+ lastScrolledSlide: slideAnchor
|
|
|
+ });
|
|
|
+ setUrlHash(sectionHash + '/' + slideAnchor); //first slide won't have slide anchor, just the section one
|
|
|
+ } else if (slideIndex != null) {
|
|
|
+ setState({
|
|
|
+ lastScrolledSlide: slideAnchor
|
|
|
+ });
|
|
|
+ setUrlHash(anchorLink);
|
|
|
+ } //section without slides
|
|
|
+ else {
|
|
|
+ setUrlHash(anchorLink);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ setBodyClass();
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Sets the URL hash.
|
|
|
+ */
|
|
|
+
|
|
|
+ function setUrlHash(url) {
|
|
|
+ if (getOptions().recordHistory) {
|
|
|
+ location.hash = url;
|
|
|
+ } else {
|
|
|
+ //Mobile Chrome doesn't work the normal way, so... lets use HTML5 for phones :)
|
|
|
+ if (isTouchDevice || isTouch) {
|
|
|
+ win.history.replaceState(undefined, undefined, '#' + url);
|
|
|
+ } else {
|
|
|
+ var baseUrl = win.location.href.split('#')[0];
|
|
|
+ win.location.replace(baseUrl + '#' + url);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Gets the name for screen readers for a section/slide navigation bullet.
|
|
|
+ */
|
|
|
+
|
|
|
+ function getBulletLinkName(i, defaultName, item) {
|
|
|
+ var anchor = defaultName === 'Section' ? getOptions().anchors[i] : getAttr(item, 'data-anchor');
|
|
|
+ return encodeURI(getOptions().navigationTooltips[i] || anchor || defaultName + ' ' + (i + 1));
|
|
|
+ }
|
|
|
+
|
|
|
+ function slideBulletHandler(e) {
|
|
|
+ // not all events are cancellable
|
|
|
+ // https://www.uriports.com/blog/easy-fix-for-intervention-ignored-attempt-to-cancel-a-touchmove-event-with-cancelable-false/
|
|
|
+ if (e.cancelable) {
|
|
|
+ preventDefault(e);
|
|
|
+ }
|
|
|
+
|
|
|
+ setState({
|
|
|
+ scrollTrigger: 'horizontalNav'
|
|
|
+ });
|
|
|
+ /*jshint validthis:true */
|
|
|
+
|
|
|
+ var sectionElem = closest(this, SECTION_SEL);
|
|
|
+ var slides = $(SLIDES_WRAPPER_SEL, closest(this, SECTION_SEL))[0];
|
|
|
+ var section = getPanelByElement(getState().sections, sectionElem);
|
|
|
+ var destiny = section.slides[index(closest(this, 'li'))];
|
|
|
+ EventEmitter.emit(events.landscapeScroll, {
|
|
|
+ slides: slides,
|
|
|
+ destination: destiny.item
|
|
|
+ });
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Sets the state for the horizontal bullet navigations.
|
|
|
+ */
|
|
|
+
|
|
|
+ function activeSlidesNavigation(slidesNav, slideIndex) {
|
|
|
+ if (getOptions().slidesNavigation && slidesNav != null) {
|
|
|
+ removeClass($(ACTIVE_SEL, slidesNav), ACTIVE);
|
|
|
+ addClass($('a', $('li', slidesNav)[slideIndex]), ACTIVE);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Creates a landscape navigation bar with dots for horizontal sliders.
|
|
|
+ */
|
|
|
+
|
|
|
+ function addSlidesNavigation(section) {
|
|
|
+ var sectionElem = section.item;
|
|
|
+ var numSlides = section.slides.length;
|
|
|
+ appendTo(createElementFromHTML('<div class="' + SLIDES_NAV + '"><ul></ul></div>'), sectionElem);
|
|
|
+ var nav = $(SLIDES_NAV_SEL, sectionElem)[0]; //top or bottom
|
|
|
+
|
|
|
+ addClass(nav, 'fp-' + getOptions().slidesNavPosition);
|
|
|
+
|
|
|
+ for (var i = 0; i < numSlides; i++) {
|
|
|
+ var slide = $(SLIDE_SEL, sectionElem)[i];
|
|
|
+ appendTo(createElementFromHTML('<li><a href="#"><span class="fp-sr-only">' + getBulletLinkName(i, 'Slide', slide) + '</span><span></span></a></li>'), $('ul', nav)[0]);
|
|
|
+ } //centering it
|
|
|
+
|
|
|
+
|
|
|
+ css(nav, {
|
|
|
+ 'margin-left': '-' + nav.innerWidth / 2 + 'px'
|
|
|
+ });
|
|
|
+ var activeSlideIndex = section.activeSlide ? section.activeSlide.index() : 0;
|
|
|
+ addClass($('a', $('li', nav)[activeSlideIndex]), ACTIVE);
|
|
|
+ }
|
|
|
+
|
|
|
+ var isScrollAllowed = {};
|
|
|
+ isScrollAllowed.m = {
|
|
|
+ 'up': true,
|
|
|
+ 'down': true,
|
|
|
+ 'left': true,
|
|
|
+ 'right': true
|
|
|
+ };
|
|
|
+ isScrollAllowed.k = deepExtend({}, isScrollAllowed.m);
|
|
|
+ /**
|
|
|
+ * Allowing or disallowing the mouse/swipe scroll in a given direction. (not for keyboard)
|
|
|
+ * @param type m (mouse) or k (keyboard)
|
|
|
+ */
|
|
|
+
|
|
|
+ function setIsScrollAllowed(value, direction, type) {
|
|
|
+ //up, down, left, right
|
|
|
+ if (direction !== 'all') {
|
|
|
+ isScrollAllowed[type][direction] = value;
|
|
|
+ } //all directions?
|
|
|
+ else {
|
|
|
+ Object.keys(isScrollAllowed[type]).forEach(function (key) {
|
|
|
+ isScrollAllowed[type][key] = value;
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function getIsScrollAllowed() {
|
|
|
+ return isScrollAllowed;
|
|
|
+ }
|
|
|
+
|
|
|
+ EventEmitter.on(events.onClickOrTouch, onClickOrTouch$2);
|
|
|
+
|
|
|
+ function onClickOrTouch$2(params) {
|
|
|
+ var target = params.target;
|
|
|
+
|
|
|
+ if (matches(target, SLIDES_ARROW_SEL) || closest(target, SLIDES_ARROW_SEL)) {
|
|
|
+ slideArrowHandler.call(target, params);
|
|
|
+ }
|
|
|
+ } //Scrolling horizontally when clicking on the slider controls.
|
|
|
+
|
|
|
+
|
|
|
+ function slideArrowHandler() {
|
|
|
+ /*jshint validthis:true */
|
|
|
+ var section = closest(this, SECTION_SEL);
|
|
|
+ /*jshint validthis:true */
|
|
|
+
|
|
|
+ if (hasClass(this, SLIDES_PREV)) {
|
|
|
+ if (getIsScrollAllowed().m.left) {
|
|
|
+ setState({
|
|
|
+ scrollTrigger: 'slideArrow'
|
|
|
+ });
|
|
|
+ EventEmitter.emit(events.moveSlideLeft, {
|
|
|
+ section: section
|
|
|
+ });
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (getIsScrollAllowed().m.right) {
|
|
|
+ setState({
|
|
|
+ scrollTrigger: 'slideArrow'
|
|
|
+ });
|
|
|
+ EventEmitter.emit(events.moveSlideRight, {
|
|
|
+ section: section
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Creates the control arrows for the given section
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function createSlideArrows(section) {
|
|
|
+ var sectionElem = section.item;
|
|
|
+ var arrows = [createElementFromHTML(getOptions().controlArrowsHTML[0]), createElementFromHTML(getOptions().controlArrowsHTML[1])];
|
|
|
+ after($(SLIDES_WRAPPER_SEL, sectionElem)[0], arrows);
|
|
|
+ addClass(arrows, SLIDES_ARROW);
|
|
|
+ addClass(arrows[0], SLIDES_PREV);
|
|
|
+ addClass(arrows[1], SLIDES_NEXT);
|
|
|
+
|
|
|
+ if (getOptions().controlArrowColor !== '#fff') {
|
|
|
+ css($(SLIDES_ARROW_NEXT_SEL, sectionElem), {
|
|
|
+ 'border-color': 'transparent transparent transparent ' + getOptions().controlArrowColor
|
|
|
+ });
|
|
|
+ css($(SLIDES_ARROW_PREV_SEL, sectionElem), {
|
|
|
+ 'border-color': 'transparent ' + getOptions().controlArrowColor + ' transparent transparent'
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!getOptions().loopHorizontal) {
|
|
|
+ hide($(SLIDES_ARROW_PREV_SEL, sectionElem));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function toggleControlArrows(v) {
|
|
|
+ if (!getOptions().loopHorizontal && getOptions().controlArrows) {
|
|
|
+ //hidding it for the fist slide, showing for the rest
|
|
|
+ toggle($(SLIDES_ARROW_PREV_SEL, v.section), v.slideIndex !== 0); //hidding it for the last slide, showing for the rest
|
|
|
+
|
|
|
+ toggle($(SLIDES_ARROW_NEXT_SEL, v.section), next(v.destiny) != null);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ FP.setRecordHistory = setRecordHistory;
|
|
|
+ /**
|
|
|
+ * Defines wheter to record the history for each hash change in the URL.
|
|
|
+ */
|
|
|
+
|
|
|
+ function setRecordHistory(value, type) {
|
|
|
+ setVariableState('recordHistory', value, type);
|
|
|
+ }
|
|
|
+
|
|
|
+ FP.setAutoScrolling = setAutoScrolling;
|
|
|
+ FP.test.setAutoScrolling = setAutoScrolling;
|
|
|
+ /**
|
|
|
+ * Sets the autoScroll option.
|
|
|
+ * It changes the scroll bar visibility and the history of the site as a result.
|
|
|
+ */
|
|
|
+
|
|
|
+ function setAutoScrolling(value, type) {
|
|
|
+ //removing the transformation
|
|
|
+ if (!value) {
|
|
|
+ silentScroll(0);
|
|
|
+ }
|
|
|
+
|
|
|
+ setVariableState('autoScrolling', value, type);
|
|
|
+ var element = getState().activeSection.item;
|
|
|
+
|
|
|
+ if (getOptions().autoScrolling && !getOptions().scrollBar) {
|
|
|
+ css($htmlBody, {
|
|
|
+ 'overflow': 'hidden',
|
|
|
+ 'height': '100%'
|
|
|
+ });
|
|
|
+ removeClass($body, 'fp-scrollable');
|
|
|
+ setRecordHistory(getOriginals().recordHistory, 'internal'); //for IE touch devices
|
|
|
+
|
|
|
+ css(getContainer(), {
|
|
|
+ '-ms-touch-action': 'none',
|
|
|
+ 'touch-action': 'none'
|
|
|
+ });
|
|
|
+
|
|
|
+ if (element != null) {
|
|
|
+ //moving the container up
|
|
|
+ silentScroll(element.offsetTop);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ css($htmlBody, {
|
|
|
+ 'overflow': 'visible',
|
|
|
+ 'height': 'initial'
|
|
|
+ });
|
|
|
+ addClass($body, 'fp-scrollable');
|
|
|
+ var recordHistory = !getOptions().autoScrolling ? false : getOriginals().recordHistory;
|
|
|
+ setRecordHistory(recordHistory, 'internal'); //for IE touch devices
|
|
|
+
|
|
|
+ css(getContainer(), {
|
|
|
+ '-ms-touch-action': '',
|
|
|
+ 'touch-action': ''
|
|
|
+ }); //scrolling the page to the section with no animation
|
|
|
+
|
|
|
+ if (element != null) {
|
|
|
+ var scrollSettings = getScrollSettings(element.offsetTop);
|
|
|
+ scrollSettings.element.scrollTo(0, scrollSettings.options);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ //@ts-check
|
|
|
+ /**
|
|
|
+ * Adds sections before or after the current one to create the infinite effect.
|
|
|
+ */
|
|
|
+
|
|
|
+ function createInfiniteSections(v) {
|
|
|
+ setState({
|
|
|
+ isDoingContinousVertical: true
|
|
|
+ });
|
|
|
+ var activeSectionItem = getState().activeSection.item; // Scrolling down
|
|
|
+
|
|
|
+ if (!v.isMovementUp) {
|
|
|
+ // Move all previous sections to after the active section
|
|
|
+ after(activeSectionItem, prevAll(activeSectionItem, SECTION_SEL).reverse());
|
|
|
+ } else {
|
|
|
+ // Scrolling up
|
|
|
+ // Move all next sections to before the active section
|
|
|
+ before(activeSectionItem, nextAll(activeSectionItem, SECTION_SEL));
|
|
|
+ } // Maintain the displayed position (now that we changed the element order)
|
|
|
+
|
|
|
+
|
|
|
+ silentScroll(getState().activeSection.item.offsetTop); // Maintain the active slides visible in the viewport
|
|
|
+
|
|
|
+ keepSlidesPosition$1(); // save for later the elements that still need to be reordered
|
|
|
+
|
|
|
+ v.wrapAroundElements = activeSectionItem; // Recalculate animation variables
|
|
|
+
|
|
|
+ v.dtop = v.element.offsetTop;
|
|
|
+ v.yMovement = getYmovement(getState().activeSection, v.element);
|
|
|
+ return v;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Maintains the active slides in the viewport
|
|
|
+ * (Because the `scroll` animation might get lost with some actions, such as when using continuousVertical)
|
|
|
+ */
|
|
|
+
|
|
|
+ function keepSlidesPosition$1() {
|
|
|
+ var activeSlides = $(SLIDE_ACTIVE_SEL);
|
|
|
+
|
|
|
+ for (var i = 0; i < activeSlides.length; i++) {
|
|
|
+ silentLandscapeScroll(activeSlides[i], 'internal');
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ //@ts-check
|
|
|
+ /**
|
|
|
+ * Maintains the active slides in the viewport
|
|
|
+ * (Because the `scroll` animation might get lost with some actions, such as when using continuousVertical)
|
|
|
+ */
|
|
|
+
|
|
|
+ function keepSlidesPosition() {
|
|
|
+ var activeSlides = $(SLIDE_ACTIVE_SEL);
|
|
|
+
|
|
|
+ for (var i = 0; i < activeSlides.length; i++) {
|
|
|
+ silentLandscapeScroll(activeSlides[i], 'internal');
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Fix section order after continuousVertical changes have been animated
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function continuousVerticalFixSectionOrder(v) {
|
|
|
+ // If continuousVertical is in effect (and autoScrolling would also be in effect then),
|
|
|
+ // finish moving the elements around so the direct navigation will function more simply
|
|
|
+ if (v.wrapAroundElements == null) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (v.isMovementUp) {
|
|
|
+ before($(SECTION_SEL)[0], v.wrapAroundElements);
|
|
|
+ } else {
|
|
|
+ after($(SECTION_SEL)[getState().sections.length - 1], v.wrapAroundElements);
|
|
|
+ }
|
|
|
+
|
|
|
+ silentScroll(getState().activeSection.item.offsetTop); // Maintain the active slides visible in the viewport
|
|
|
+
|
|
|
+ keepSlidesPosition();
|
|
|
+ setState({
|
|
|
+ isDoingContinousVertical: false
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Makes sure lazyload is done for other sections in the viewport that are not the
|
|
|
+ * active one.
|
|
|
+ */
|
|
|
+
|
|
|
+ function lazyLoadOthers() {
|
|
|
+ var hasAutoHeightSections = $(AUTO_HEIGHT_SEL)[0] || isResponsiveMode() && $(AUTO_HEIGHT_RESPONSIVE_SEL)[0]; //quitting when it doesn't apply
|
|
|
+
|
|
|
+ if (!getOptions().lazyLoading || !hasAutoHeightSections) {
|
|
|
+ return;
|
|
|
+ } //making sure to lazy load auto-height sections that are in the viewport
|
|
|
+
|
|
|
+
|
|
|
+ $(SECTION_SEL + ':not(' + ACTIVE_SEL + ')').forEach(function (section) {
|
|
|
+ if (isSectionInViewport(section)) {
|
|
|
+ lazyLoad(section);
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Determines whether a section is in the viewport or not.
|
|
|
+ */
|
|
|
+
|
|
|
+ function isSectionInViewport(el) {
|
|
|
+ var rect = el.getBoundingClientRect();
|
|
|
+ var top = rect.top;
|
|
|
+ var bottom = rect.bottom; //sometimes there's a 1px offset on the bottom of the screen even when the
|
|
|
+ //section's height is the window.innerHeight one. I guess because pixels won't allow decimals.
|
|
|
+ //using this prevents from lazyLoading the section that is not yet visible
|
|
|
+ //(only 1 pixel offset is)
|
|
|
+
|
|
|
+ var pixelOffset = 2;
|
|
|
+ var isTopInView = top + pixelOffset < state.windowsHeight && top > 0;
|
|
|
+ var isBottomInView = bottom > pixelOffset && bottom < state.windowsHeight;
|
|
|
+ return isTopInView || isBottomInView;
|
|
|
+ }
|
|
|
+
|
|
|
+ function tooltipTextHandler() {
|
|
|
+ /*jshint validthis:true */
|
|
|
+ trigger(prev(this), 'click');
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Activating the vertical navigation bullets according to the given slide name.
|
|
|
+ */
|
|
|
+
|
|
|
+ function activateNavDots(name, sectionIndex) {
|
|
|
+ var nav = $(SECTION_NAV_SEL)[0];
|
|
|
+
|
|
|
+ if (getOptions().navigation && nav != null && nav.style.display !== 'none') {
|
|
|
+ removeClass($(ACTIVE_SEL, nav), ACTIVE);
|
|
|
+
|
|
|
+ if (name) {
|
|
|
+ addClass($('a[href="#' + name + '"]', nav), ACTIVE);
|
|
|
+ } else {
|
|
|
+ addClass($('a', $('li', nav)[sectionIndex]), ACTIVE);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Creates a vertical navigation bar.
|
|
|
+ */
|
|
|
+
|
|
|
+ function addVerticalNavigation() {
|
|
|
+ remove($(SECTION_NAV_SEL));
|
|
|
+ var navigation = doc.createElement('div');
|
|
|
+ navigation.setAttribute('id', SECTION_NAV);
|
|
|
+ var divUl = doc.createElement('ul');
|
|
|
+ navigation.appendChild(divUl);
|
|
|
+ appendTo(navigation, $body);
|
|
|
+ var nav = $(SECTION_NAV_SEL)[0];
|
|
|
+ addClass(nav, 'fp-' + getOptions().navigationPosition);
|
|
|
+
|
|
|
+ if (getOptions().showActiveTooltip) {
|
|
|
+ addClass(nav, SHOW_ACTIVE_TOOLTIP);
|
|
|
+ }
|
|
|
+
|
|
|
+ var li = '';
|
|
|
+
|
|
|
+ for (var i = 0; i < getState().sections.length; i++) {
|
|
|
+ var section = getState().sections[i];
|
|
|
+ var link = '';
|
|
|
+
|
|
|
+ if (getOptions().anchors.length) {
|
|
|
+ link = section.anchor;
|
|
|
+ }
|
|
|
+
|
|
|
+ li += '<li><a href="#' + encodeURI(link) + '"><span class="fp-sr-only">' + getBulletLinkName(section.index(), 'Section') + '</span><span></span></a>'; // Only add tooltip if needed (defined by user)
|
|
|
+
|
|
|
+ var tooltip = getOptions().navigationTooltips[section.index()];
|
|
|
+
|
|
|
+ if (typeof tooltip !== 'undefined' && tooltip !== '') {
|
|
|
+ li += '<div class="' + SECTION_NAV_TOOLTIP + ' fp-' + getOptions().navigationPosition + '">' + tooltip + '</div>';
|
|
|
+ }
|
|
|
+
|
|
|
+ li += '</li>';
|
|
|
+ }
|
|
|
+
|
|
|
+ $('ul', nav)[0].innerHTML = li; //activating the current active section
|
|
|
+
|
|
|
+ var bullet = $('li', $(SECTION_NAV_SEL)[0])[getState().activeSection.index()];
|
|
|
+ addClass($('a', bullet), ACTIVE);
|
|
|
+ } //Scrolls to the section when clicking the navigation bullet
|
|
|
+
|
|
|
+ function sectionBulletHandler(e) {
|
|
|
+ if (e.preventDefault) {
|
|
|
+ preventDefault(e);
|
|
|
+ }
|
|
|
+
|
|
|
+ setState({
|
|
|
+ scrollTrigger: 'verticalNav'
|
|
|
+ });
|
|
|
+ /*jshint validthis:true */
|
|
|
+ // @ts-ignore
|
|
|
+
|
|
|
+ var indexBullet = index(closest(this, SECTION_NAV_SEL + ' li'));
|
|
|
+ EventEmitter.emit(events.scrollPage, {
|
|
|
+ destination: getState().sections[indexBullet]
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sets to active the current menu and vertical nav items.
|
|
|
+ */
|
|
|
+
|
|
|
+ function activateMenuAndNav(anchor, index) {
|
|
|
+ activateMenuElement(anchor);
|
|
|
+ activateNavDots(anchor, index);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Activating the website main menu elements according to the given slide name.
|
|
|
+ */
|
|
|
+
|
|
|
+ function activateMenuElement(name) {
|
|
|
+ if (getOptions().menu && getOptions().menu.length) {
|
|
|
+ $(getOptions().menu).forEach(function (menu) {
|
|
|
+ if (menu != null) {
|
|
|
+ removeClass($(ACTIVE_SEL, menu), ACTIVE);
|
|
|
+ addClass($('[data-menuanchor="' + name + '"]', menu), ACTIVE);
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ new Date().getTime();
|
|
|
+ /**
|
|
|
+ * Triggers the callback once per scroll wheel action.
|
|
|
+ * Based on scrolling speed delay.
|
|
|
+ */
|
|
|
+
|
|
|
+ var oncePerScroll = function () {
|
|
|
+ var canTriggerEvent = true;
|
|
|
+ var prevWheelTime = new Date().getTime();
|
|
|
+ var result;
|
|
|
+ var isScrollingOnInit = !win.fullpage_api;
|
|
|
+ return function (scrollTrigger, callback) {
|
|
|
+ var currentTime = new Date().getTime();
|
|
|
+ var timeThreshold = scrollTrigger === 'wheel' ? getOptions().scrollingSpeed : 100;
|
|
|
+ canTriggerEvent = isScrollingOnInit || currentTime - prevWheelTime >= timeThreshold;
|
|
|
+ isScrollingOnInit = !win.fullpage_api;
|
|
|
+
|
|
|
+ if (canTriggerEvent) {
|
|
|
+ result = callback();
|
|
|
+ prevWheelTime = currentTime;
|
|
|
+ }
|
|
|
+
|
|
|
+ return typeof result !== 'undefined' ? result : true;
|
|
|
+ };
|
|
|
+ }();
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Fires the wheel event once per mouse wheel trigger.
|
|
|
+ */
|
|
|
+
|
|
|
+ function fireCallbackOncePerScroll(callbackName, params) {
|
|
|
+ if (!isFunction(getOptions().beforeLeave)) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ var result = oncePerScroll(getState().scrollTrigger, function () {
|
|
|
+ return fireCallback(callbackName, params);
|
|
|
+ });
|
|
|
+ return result;
|
|
|
+ }
|
|
|
+
|
|
|
+ FP.moveTo = moveTo;
|
|
|
+
|
|
|
+ FP.getScrollY = function () {
|
|
|
+ return state.scrollY;
|
|
|
+ };
|
|
|
+
|
|
|
+ var g_afterSectionLoadsId;
|
|
|
+ var g_transitionLapseId;
|
|
|
+ EventEmitter.on(events.onDestroy, onDestroy$8);
|
|
|
+ /**
|
|
|
+ * Scrolls the site to the given element and scrolls to the slide if a callback is given.
|
|
|
+ */
|
|
|
+
|
|
|
+ function scrollPage(section, callback, isMovementUp) {
|
|
|
+ var element = section.item;
|
|
|
+
|
|
|
+ if (element == null) {
|
|
|
+ return;
|
|
|
+ } //there's no element to scroll, leaving the function
|
|
|
+
|
|
|
+
|
|
|
+ var dtop = getDestinationPosition(element);
|
|
|
+ var slideAnchorLink;
|
|
|
+ var slideIndex; //local variables
|
|
|
+
|
|
|
+ var v = {
|
|
|
+ "element": element,
|
|
|
+ "callback": callback,
|
|
|
+ "isMovementUp": isMovementUp,
|
|
|
+ "dtop": dtop,
|
|
|
+ "yMovement": getYmovement(getState().activeSection, element),
|
|
|
+ "anchorLink": section.anchor,
|
|
|
+ "sectionIndex": section.index(),
|
|
|
+ "activeSlide": section.activeSlide ? section.activeSlide.item : null,
|
|
|
+ "leavingSection": getState().activeSection.index() + 1,
|
|
|
+ //caching the value of isResizing at the momment the function is called
|
|
|
+ //because it will be checked later inside a setTimeout and the value might change
|
|
|
+ "localIsResizing": state.isResizing,
|
|
|
+ "items": {
|
|
|
+ "origin": getState().activeSection,
|
|
|
+ "destination": section
|
|
|
+ },
|
|
|
+ "direction": null
|
|
|
+ }; //quiting when destination scroll is the same as the current one
|
|
|
+
|
|
|
+ if (getState().activeSection.item == element && !state.isResizing || getOptions().scrollBar && getScrollTop() === v.dtop && !hasClass(element, AUTO_HEIGHT)) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (v.activeSlide != null) {
|
|
|
+ slideAnchorLink = getAttr(v.activeSlide, 'data-anchor');
|
|
|
+ slideIndex = index(v.activeSlide, null);
|
|
|
+ } //callback (onLeave) if the site is not just resizing and readjusting the slides
|
|
|
+
|
|
|
+
|
|
|
+ if (!v.localIsResizing) {
|
|
|
+ var direction = v.yMovement; //required for continousVertical
|
|
|
+
|
|
|
+ if (typeof isMovementUp !== 'undefined') {
|
|
|
+ direction = isMovementUp ? 'up' : 'down';
|
|
|
+ } //for the callback
|
|
|
+
|
|
|
+
|
|
|
+ v.direction = direction;
|
|
|
+
|
|
|
+ if (isFunction(getOptions().beforeLeave)) {
|
|
|
+ if (fireCallbackOncePerScroll('beforeLeave', v) === false) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (isFunction(getOptions().onLeave)) {
|
|
|
+ if (!fireCallback('onLeave', v)) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } // If continuousVertical && we need to wrap around
|
|
|
+
|
|
|
+
|
|
|
+ if (getOptions().autoScrolling && getOptions().continuousVertical && typeof v.isMovementUp !== "undefined" && (!v.isMovementUp && v.yMovement == 'up' || // Intending to scroll down but about to go up or
|
|
|
+ v.isMovementUp && v.yMovement == 'down')) {
|
|
|
+ // intending to scroll up but about to go down
|
|
|
+ v = createInfiniteSections(v);
|
|
|
+ } //pausing media of the leaving section (if we are not just resizing, as destinatino will be the same one)
|
|
|
+
|
|
|
+
|
|
|
+ if (!v.localIsResizing) {
|
|
|
+ stopMedia(getState().activeSection.item);
|
|
|
+ }
|
|
|
+
|
|
|
+ addClass(element, ACTIVE);
|
|
|
+ removeClass(siblings(element), ACTIVE);
|
|
|
+ updateState();
|
|
|
+ lazyLoad(element); //preventing from activating the MouseWheelHandler event
|
|
|
+ //more than once if the page is scrolling
|
|
|
+
|
|
|
+ setState({
|
|
|
+ canScroll: FP.test.isTesting
|
|
|
+ });
|
|
|
+ setPageStatus(slideIndex, slideAnchorLink, v.anchorLink);
|
|
|
+ EventEmitter.emit(events.onLeave, v);
|
|
|
+ performMovement(v); //flag to avoid callingn `scrollPage()` twice in case of using anchor links
|
|
|
+
|
|
|
+ setState({
|
|
|
+ lastScrolledDestiny: v.anchorLink
|
|
|
+ }); //avoid firing it twice (as it does also on scroll)
|
|
|
+
|
|
|
+ activateMenuAndNav(v.anchorLink, v.sectionIndex);
|
|
|
+ }
|
|
|
+
|
|
|
+ function onDestroy$8() {
|
|
|
+ clearTimeout(g_afterSectionLoadsId);
|
|
|
+ clearTimeout(g_transitionLapseId);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Returns the destination Y position based on the scrolling direction and
|
|
|
+ * the height of the section.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function getDestinationPosition(element) {
|
|
|
+ var elementHeight = element.offsetHeight;
|
|
|
+ var elementTop = element.offsetTop; //top of the desination will be at the top of the viewport
|
|
|
+
|
|
|
+ var position = elementTop;
|
|
|
+ var isScrollingDown = elementTop > state.previousDestTop;
|
|
|
+ var sectionBottom = position - getWindowHeight() + elementHeight;
|
|
|
+ var bigSectionsDestination = getOptions().bigSectionsDestination; //is the destination element bigger than the viewport?
|
|
|
+
|
|
|
+ if (elementHeight > getWindowHeight()) {
|
|
|
+ //scrolling up?
|
|
|
+ if (!isScrollingDown && !bigSectionsDestination || bigSectionsDestination === 'bottom') {
|
|
|
+ position = sectionBottom;
|
|
|
+ }
|
|
|
+ } //sections equal or smaller than the viewport height && scrolling down? || is resizing and its in the last section
|
|
|
+ else if (isScrollingDown || state.isResizing && next(element) == null) {
|
|
|
+ //The bottom of the destination will be at the bottom of the viewport
|
|
|
+ position = sectionBottom;
|
|
|
+ }
|
|
|
+ /*
|
|
|
+ Keeping record of the last scrolled position to determine the scrolling direction.
|
|
|
+ No conventional methods can be used as the scroll bar might not be present
|
|
|
+ AND the section might not be active if it is auto-height and didnt reach the middle
|
|
|
+ of the viewport.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ setState({
|
|
|
+ previousDestTop: position
|
|
|
+ });
|
|
|
+ return position;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Performs the vertical movement (by CSS3 or by jQuery)
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function performMovement(v) {
|
|
|
+ var isFastSpeed = getOptions().scrollingSpeed < 700;
|
|
|
+ var transitionLapse = isFastSpeed ? 700 : getOptions().scrollingSpeed;
|
|
|
+ setState({
|
|
|
+ touchDirection: 'none',
|
|
|
+ scrollY: Math.round(v.dtop)
|
|
|
+ });
|
|
|
+ EventEmitter.emit(events.onPerformMovement); // using CSS3 translate functionality
|
|
|
+
|
|
|
+ if (getOptions().css3 && getOptions().autoScrolling && !getOptions().scrollBar) {
|
|
|
+ // The first section can have a negative value in iOS 10. Not quite sure why: -0.0142822265625
|
|
|
+ // that's why we round it to 0.
|
|
|
+ var translate3d = 'translate3d(0px, -' + Math.round(v.dtop) + 'px, 0px)';
|
|
|
+ transformContainer(translate3d, true); //even when the scrollingSpeed is 0 there's a little delay, which might cause the
|
|
|
+ //scrollingSpeed to change in case of using silentMoveTo();ç
|
|
|
+
|
|
|
+ if (getOptions().scrollingSpeed) {
|
|
|
+ clearTimeout(g_afterSectionLoadsId);
|
|
|
+ g_afterSectionLoadsId = setTimeout(function () {
|
|
|
+ afterSectionLoads$1(v); //disabling canScroll when using fastSpeed
|
|
|
+
|
|
|
+ setState({
|
|
|
+ canScroll: !isFastSpeed || FP.test.isTesting
|
|
|
+ });
|
|
|
+ }, getOptions().scrollingSpeed);
|
|
|
+ } else {
|
|
|
+ afterSectionLoads$1(v);
|
|
|
+ }
|
|
|
+ } // using JS to animate
|
|
|
+ else {
|
|
|
+ var scrollSettings = getScrollSettings(v.dtop);
|
|
|
+ FP.test.top = -v.dtop + 'px';
|
|
|
+ clearTimeout(g_afterSectionLoadsId);
|
|
|
+ scrollTo(scrollSettings.element, scrollSettings.options, getOptions().scrollingSpeed, function () {
|
|
|
+ if (getOptions().scrollBar) {
|
|
|
+ /* Hack!
|
|
|
+ The timeout prevents setting the most dominant section in the viewport as "active" when the user
|
|
|
+ scrolled to a smaller section by using the mousewheel (auto scrolling) rather than draging the scroll bar.
|
|
|
+ When using scrollBar:true It seems like the scroll events still getting propagated even after the scrolling animation has finished.
|
|
|
+ */
|
|
|
+ g_afterSectionLoadsId = setTimeout(function () {
|
|
|
+ afterSectionLoads$1(v);
|
|
|
+ }, 30);
|
|
|
+ } else {
|
|
|
+ afterSectionLoads$1(v); //disabling canScroll when using fastSpeed
|
|
|
+
|
|
|
+ setState({
|
|
|
+ canScroll: !isFastSpeed || FP.test.isTesting
|
|
|
+ });
|
|
|
+ }
|
|
|
+ });
|
|
|
+ } // enabling canScroll after the minimum transition laps
|
|
|
+
|
|
|
+
|
|
|
+ if (isFastSpeed) {
|
|
|
+ clearTimeout(g_transitionLapseId);
|
|
|
+ g_transitionLapseId = setTimeout(function () {
|
|
|
+ setState({
|
|
|
+ canScroll: true
|
|
|
+ });
|
|
|
+ }, transitionLapse);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Actions to do once the section is loaded.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function afterSectionLoads$1(v) {
|
|
|
+ setState({
|
|
|
+ isBeyondFullpage: false
|
|
|
+ });
|
|
|
+ continuousVerticalFixSectionOrder(v); //callback (afterLoad) if the site is not just resizing and readjusting the slides
|
|
|
+
|
|
|
+ if (isFunction(getOptions().afterLoad) && !v.localIsResizing) {
|
|
|
+ fireCallback('afterLoad', v);
|
|
|
+ }
|
|
|
+
|
|
|
+ updateState();
|
|
|
+
|
|
|
+ if (!v.localIsResizing) {
|
|
|
+ playMedia(v.element);
|
|
|
+ }
|
|
|
+
|
|
|
+ addClass(v.element, COMPLETELY);
|
|
|
+ removeClass(siblings(v.element), COMPLETELY);
|
|
|
+ lazyLoadOthers();
|
|
|
+ setState({
|
|
|
+ canScroll: true
|
|
|
+ });
|
|
|
+ EventEmitter.emit(events.afterSectionLoads, v);
|
|
|
+
|
|
|
+ if (isFunction(v.callback)) {
|
|
|
+ v.callback();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ FP.setFitToSection = setFitToSection;
|
|
|
+ FP.fitToSection = fitToSection;
|
|
|
+ /**
|
|
|
+ * Sets fitToSection
|
|
|
+ */
|
|
|
+
|
|
|
+ function setFitToSection(value, type) {
|
|
|
+ setVariableState('fitToSection', value, type);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Fits the site to the nearest active section
|
|
|
+ */
|
|
|
+
|
|
|
+ function fitToSection() {
|
|
|
+ //checking fitToSection again in case it was set to false before the timeout delay
|
|
|
+ if (state.canScroll) {
|
|
|
+ //allows to scroll to an active section and
|
|
|
+ //if the section is already active, we prevent firing callbacks
|
|
|
+ setState({
|
|
|
+ isResizing: true
|
|
|
+ });
|
|
|
+ scrollPage(state.activeSection);
|
|
|
+ setState({
|
|
|
+ isResizing: false
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ FP.setResponsive = setResponsive;
|
|
|
+ /**
|
|
|
+ * Checks if the site needs to get responsive and disables autoScrolling if so.
|
|
|
+ * A class `fp-responsive` is added to the plugin's container in case the user wants to use it for his own responsive CSS.
|
|
|
+ */
|
|
|
+
|
|
|
+ function responsive() {
|
|
|
+ var widthLimit = getOptions().responsive || getOptions().responsiveWidth; //backwards compatiblity
|
|
|
+
|
|
|
+ var heightLimit = getOptions().responsiveHeight; //only calculating what we need. Remember its called on the resize event.
|
|
|
+
|
|
|
+ var isBreakingPointWidth = widthLimit && win.innerWidth < widthLimit;
|
|
|
+ var isBreakingPointHeight = heightLimit && win.innerHeight < heightLimit;
|
|
|
+
|
|
|
+ if (widthLimit && heightLimit) {
|
|
|
+ setResponsive(isBreakingPointWidth || isBreakingPointHeight);
|
|
|
+ } else if (widthLimit) {
|
|
|
+ setResponsive(isBreakingPointWidth);
|
|
|
+ } else if (heightLimit) {
|
|
|
+ setResponsive(isBreakingPointHeight);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Turns fullPage.js to normal scrolling mode when the viewport `width` or `height`
|
|
|
+ * are smaller than the set limit values.
|
|
|
+ */
|
|
|
+
|
|
|
+ function setResponsive(active) {
|
|
|
+ var isResponsive = isResponsiveMode();
|
|
|
+
|
|
|
+ if (active) {
|
|
|
+ if (!isResponsive) {
|
|
|
+ setAutoScrolling(false, 'internal');
|
|
|
+ setFitToSection(false, 'internal');
|
|
|
+ hide($(SECTION_NAV_SEL));
|
|
|
+ addClass($body, RESPONSIVE);
|
|
|
+
|
|
|
+ if (isFunction(getOptions().afterResponsive)) {
|
|
|
+ getOptions().afterResponsive.call(getContainer(), active);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else if (isResponsive) {
|
|
|
+ setAutoScrolling(getOriginals().autoScrolling, 'internal');
|
|
|
+ setFitToSection(getOriginals().autoScrolling, 'internal');
|
|
|
+ show($(SECTION_NAV_SEL));
|
|
|
+ removeClass($body, RESPONSIVE);
|
|
|
+
|
|
|
+ if (isFunction(getOptions().afterResponsive)) {
|
|
|
+ getOptions().afterResponsive.call(getContainer(), active);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Determines whether fullpage.js is in responsive mode or not.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function isResponsiveMode() {
|
|
|
+ return hasClass($body, RESPONSIVE);
|
|
|
+ }
|
|
|
+
|
|
|
+ function addTableClass(element) {
|
|
|
+ if (!getOptions().verticalCentered) {
|
|
|
+ return;
|
|
|
+ } // Overflowing sections when scrollOverflow is disabled will be autoHeight
|
|
|
+ // and won't require vertical aligment
|
|
|
+
|
|
|
+
|
|
|
+ if (!getOptions().scrollOverflow && scrollOverflowHandler.shouldBeScrollable(element.item)) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!scrollOverflowHandler.isScrollable(element)) {
|
|
|
+ //In case we are styling for the 2nd time as in with reponsiveSlides
|
|
|
+ if (!hasClass(element.item, TABLE)) {
|
|
|
+ addClass(element.item, TABLE);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var startingSection = null;
|
|
|
+ FP.getActiveSection = getActiveSection;
|
|
|
+ function getStartingSection() {
|
|
|
+ return startingSection;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Styling vertical sections
|
|
|
+ */
|
|
|
+
|
|
|
+ function styleSection(section) {
|
|
|
+ var sectionElem = section.item;
|
|
|
+ var hasSlides = section.allSlidesItems.length;
|
|
|
+ var index = section.index(); //if no active section is defined, the 1st one will be the default one
|
|
|
+
|
|
|
+ if (!getState().activeSection && section.isVisible) {
|
|
|
+ addClass(sectionElem, ACTIVE);
|
|
|
+ updateState();
|
|
|
+ startingSection = getState().activeSection.item;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (getOptions().paddingTop) {
|
|
|
+ css(sectionElem, {
|
|
|
+ 'padding-top': getOptions().paddingTop
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ if (getOptions().paddingBottom) {
|
|
|
+ css(sectionElem, {
|
|
|
+ 'padding-bottom': getOptions().paddingBottom
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ if (typeof getOptions().sectionsColor[index] !== 'undefined') {
|
|
|
+ css(sectionElem, {
|
|
|
+ 'background-color': getOptions().sectionsColor[index]
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ if (typeof getOptions().anchors[index] !== 'undefined') {
|
|
|
+ sectionElem.setAttribute('data-anchor', section.anchor);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!hasSlides) {
|
|
|
+ addTableClass(section);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets the active section.
|
|
|
+ */
|
|
|
+
|
|
|
+ function getActiveSection() {
|
|
|
+ return getState().activeSection;
|
|
|
+ }
|
|
|
+
|
|
|
+ function getSectionFromPanel(panel) {
|
|
|
+ return panel.isSection ? panel : panel.parent;
|
|
|
+ }
|
|
|
+
|
|
|
+ var g_focusScrollableId;
|
|
|
+ EventEmitter.on(events.bindEvents, bindEvents$b);
|
|
|
+
|
|
|
+ function bindEvents$b() {
|
|
|
+ // We can't focus scrollOverflow before scrolling
|
|
|
+ // to the anchor (if we need to)
|
|
|
+ EventEmitter.on(events.onAfterRenderNoAnchor, afterRender);
|
|
|
+ EventEmitter.on(events.onLeave, scrollOverflowHandler.onLeave);
|
|
|
+ EventEmitter.on(events.onSlideLeave, scrollOverflowHandler.onLeave);
|
|
|
+ EventEmitter.on(events.afterSlideLoads, scrollOverflowHandler.afterLoad);
|
|
|
+ EventEmitter.on(events.afterSectionLoads, scrollOverflowHandler.afterLoad);
|
|
|
+ EventEmitter.on(events.onDestroy, onDestroy$7);
|
|
|
+ docAddEvent('keyup', scrollOverflowHandler.keyUpHandler);
|
|
|
+ }
|
|
|
+
|
|
|
+ function afterRender() {
|
|
|
+ if (getOptions().scrollOverflow && !getOptions().scrollBar) {
|
|
|
+ scrollOverflowHandler.makeScrollable();
|
|
|
+ scrollOverflowHandler.focusScrollable();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function onDestroy$7() {
|
|
|
+ EventEmitter.removeListener(events.onAfterRenderNoAnchor, afterRender);
|
|
|
+ docRemoveEvent('keyup', scrollOverflowHandler.keyUpHandler);
|
|
|
+ }
|
|
|
+
|
|
|
+ var scrollOverflowHandler = {
|
|
|
+ focusedElem: null,
|
|
|
+ shouldFocusScrollable: true,
|
|
|
+ isInnerScrollAllowed: true,
|
|
|
+ timeBeforeReachingLimit: null,
|
|
|
+ timeLastScroll: null,
|
|
|
+ preventScrollWithMouseWheel: function preventScrollWithMouseWheel(e) {
|
|
|
+ if (!state.canScroll) {
|
|
|
+ preventDefault(e);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ },
|
|
|
+ preventScrollWithKeyboard: function preventScrollWithKeyboard(e) {
|
|
|
+ if (!isInsideInput() && getOptions().keyboardScrolling) {
|
|
|
+ var directionKeys = [38, 33, 32, 40, 34, 36, 35];
|
|
|
+
|
|
|
+ if (directionKeys.indexOf(e.keyCode) > -1 && !scrollOverflowHandler.isInnerScrollAllowed) {
|
|
|
+ preventDefault(e);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ keyUpHandler: function keyUpHandler() {
|
|
|
+ scrollOverflowHandler.shouldFocusScrollable = state.canScroll;
|
|
|
+ },
|
|
|
+ // Leaving sections or slides
|
|
|
+ onLeave: function onLeave() {
|
|
|
+ clearTimeout(g_focusScrollableId);
|
|
|
+ scrollOverflowHandler.isInnerScrollAllowed = false;
|
|
|
+ },
|
|
|
+ // Loading sections or slides
|
|
|
+ afterLoad: function afterLoad() {
|
|
|
+ scrollOverflowHandler.isInnerScrollAllowed = false; // Delaying it to avoid issues on Safari when focusing elements #4484 & #4493
|
|
|
+
|
|
|
+ clearTimeout(g_focusScrollableId);
|
|
|
+ g_focusScrollableId = setTimeout(function () {
|
|
|
+ scrollOverflowHandler.shouldFocusScrollable = state.canScroll;
|
|
|
+ }, 200);
|
|
|
+ },
|
|
|
+ // Unfocusing the scrollable element from the orgin section/slide
|
|
|
+ unfocusScrollable: function unfocusScrollable() {
|
|
|
+ if (doc.activeElement === this.focusedElem) {
|
|
|
+ // @ts-ignore
|
|
|
+ this.focusedElem.blur();
|
|
|
+ scrollOverflowHandler.isInnerScrollAllowed = false;
|
|
|
+ }
|
|
|
+ },
|
|
|
+ focusScrollable: function focusScrollable() {
|
|
|
+ if (!getOptions().scrollOverflow || !scrollOverflowHandler.shouldFocusScrollable) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ scrollOverflowHandler.unfocusScrollable();
|
|
|
+ var scrollableItem = scrollOverflowHandler.getScrollableItem(getState().activeSection.item); // On desktop we focus the scrollable to be able to use the mouse wheel
|
|
|
+ // We avoid it on mobile due to a bug in iOS Safari
|
|
|
+
|
|
|
+ if (scrollableItem && !isTouchDevice && !isTouch) {
|
|
|
+ this.focusedElem = scrollableItem; // Forcing the focus on the next paint
|
|
|
+ // to avoid issue #4484 & #4493 on Safari
|
|
|
+
|
|
|
+ requestAnimationFrame(function () {
|
|
|
+ scrollableItem.focus();
|
|
|
+ scrollOverflowHandler.isInnerScrollAllowed = true;
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ scrollOverflowHandler.shouldFocusScrollable = false;
|
|
|
+ },
|
|
|
+ makeScrollable: function makeScrollable() {
|
|
|
+ if (getOptions().scrollOverflowMacStyle && !isMacDevice) {
|
|
|
+ addClass($body, 'fp-scroll-mac');
|
|
|
+ }
|
|
|
+
|
|
|
+ getState().panels.forEach(function (el) {
|
|
|
+ if (el.slides && el.slides.length) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (hasClass(el.item, AUTO_HEIGHT_RESPONSIVE) && isResponsiveMode()) {
|
|
|
+ return;
|
|
|
+ } else {
|
|
|
+ var item = getSlideOrSection(el.item);
|
|
|
+ var shouldBeScrollable = scrollOverflowHandler.shouldBeScrollable(el.item);
|
|
|
+ var section = getSectionFromPanel(el);
|
|
|
+
|
|
|
+ if (isIE11) {
|
|
|
+ var toggleAction = shouldBeScrollable ? 'addClass' : 'removeClass';
|
|
|
+ utils[toggleAction](section.item, IS_OVERFLOW);
|
|
|
+ utils[toggleAction](el.item, IS_OVERFLOW);
|
|
|
+ } else {
|
|
|
+ addClass(section.item, IS_OVERFLOW);
|
|
|
+ addClass(el.item, IS_OVERFLOW);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!el.hasScroll) {
|
|
|
+ scrollOverflowHandler.createWrapper(item);
|
|
|
+ scrollOverflowHandler.bindEvents(item);
|
|
|
+ } // updating the state now in case
|
|
|
+ // this is executed on page load (after images load)
|
|
|
+
|
|
|
+
|
|
|
+ el.hasScroll = true;
|
|
|
+ }
|
|
|
+ });
|
|
|
+ },
|
|
|
+ bindEvents: function bindEvents(item) {
|
|
|
+ scrollOverflowHandler.getScrollableItem(item).addEventListener('scroll', scrollOverflowHandler.onPanelScroll);
|
|
|
+ item.addEventListener('wheel', scrollOverflowHandler.preventScrollWithMouseWheel, {
|
|
|
+ passive: false
|
|
|
+ });
|
|
|
+ item.addEventListener('keydown', scrollOverflowHandler.preventScrollWithKeyboard, {
|
|
|
+ passive: false
|
|
|
+ });
|
|
|
+ },
|
|
|
+ createWrapper: function createWrapper(item) {
|
|
|
+ var overflowWrapper = document.createElement('div');
|
|
|
+ overflowWrapper.className = OVERFLOW;
|
|
|
+ wrapInner(item, overflowWrapper);
|
|
|
+ overflowWrapper.setAttribute('tabindex', '-1');
|
|
|
+ },
|
|
|
+ destroyWrapper: function destroyWrapper(item) {
|
|
|
+ var overflowWrapper = $(OVERFLOW_SEL, item)[0];
|
|
|
+
|
|
|
+ if (overflowWrapper) {
|
|
|
+ unwrap(overflowWrapper);
|
|
|
+ item.removeAttribute('tabindex');
|
|
|
+ }
|
|
|
+ },
|
|
|
+ getScrollableItem: function getScrollableItem(sectionItem) {
|
|
|
+ var panel = getSlideOrSection(sectionItem);
|
|
|
+ return $(OVERFLOW_SEL, panel)[0] || panel;
|
|
|
+ },
|
|
|
+ hasScroll: function hasScroll(panelItem) {
|
|
|
+ return hasClass(panelItem, OVERFLOW) || $(OVERFLOW_SEL, panelItem)[0] != null;
|
|
|
+ },
|
|
|
+ isScrollable: function isScrollable(panel) {
|
|
|
+ return panel.isSection && panel.activeSlide ? panel.activeSlide.hasScroll : panel.hasScroll;
|
|
|
+ },
|
|
|
+ shouldBeScrollable: function shouldBeScrollable(item) {
|
|
|
+ var scrollable = scrollOverflowHandler.getScrollableItem(item);
|
|
|
+ return scrollable.scrollHeight > win.innerHeight;
|
|
|
+ },
|
|
|
+ isScrolled: function isScrolled(direction, el) {
|
|
|
+ if (!state.canScroll) {
|
|
|
+ return false;
|
|
|
+ } // we won't allow scrolloverflow on scrollBar:true
|
|
|
+
|
|
|
+
|
|
|
+ if (getOptions().scrollBar) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ var scrollableItem = scrollOverflowHandler.getScrollableItem(el);
|
|
|
+
|
|
|
+ if (!getOptions().scrollOverflow || !hasClass(scrollableItem, OVERFLOW) || // Checking the section first
|
|
|
+ // In case they apply to both section + slide #4505
|
|
|
+ hasClass(el, 'fp-noscroll') || // Checking the slide (in case it has)
|
|
|
+ hasClass(getSlideOrSection(el), 'fp-noscroll')) {
|
|
|
+ return true;
|
|
|
+ } // ie11 wrongly calculates scrollHeight when using the CSS style
|
|
|
+ // overflow: auto It adds 1 more pixel compared to offsetHeight
|
|
|
+
|
|
|
+
|
|
|
+ var ie11offset = isIE11 ? 1 : 0;
|
|
|
+ var positionY = scrollableItem.scrollTop;
|
|
|
+ var isTopReached = direction === 'up' && positionY <= 0;
|
|
|
+ var isBottomReached = direction === 'down' && scrollableItem.scrollHeight <= Math.ceil(scrollableItem.offsetHeight + positionY) + ie11offset;
|
|
|
+ var isScrolled = isTopReached || isBottomReached;
|
|
|
+
|
|
|
+ if (!isScrolled) {
|
|
|
+ this.timeBeforeReachingLimit = new Date().getTime();
|
|
|
+ }
|
|
|
+
|
|
|
+ return isScrolled;
|
|
|
+ },
|
|
|
+ shouldMovePage: function shouldMovePage() {
|
|
|
+ this.timeLastScroll = new Date().getTime();
|
|
|
+ var timeDiff = this.timeLastScroll - scrollOverflowHandler.timeBeforeReachingLimit;
|
|
|
+ var isUsingTouch = isTouchDevice || isTouch;
|
|
|
+ var isGrabbing = isUsingTouch && state.isGrabbing;
|
|
|
+ var isNotFirstTimeReachingLimit = state.isUsingWheel && timeDiff > 600;
|
|
|
+ return isGrabbing && timeDiff > 400 || isNotFirstTimeReachingLimit;
|
|
|
+ },
|
|
|
+ onPanelScroll: function () {
|
|
|
+ var prevPosition = 0;
|
|
|
+ return function (e) {
|
|
|
+ var currentPosition = e.target.scrollTop;
|
|
|
+ var direction = state.touchDirection !== 'none' ? state.touchDirection : prevPosition < currentPosition ? 'down' : 'up';
|
|
|
+ prevPosition = currentPosition;
|
|
|
+
|
|
|
+ if (isFunction(getOptions().onScrollOverflow)) {
|
|
|
+ fireCallback('onScrollOverflow', {
|
|
|
+ position: currentPosition,
|
|
|
+ direction: direction
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ if (hasClass(e.target, OVERFLOW) && state.canScroll) {
|
|
|
+ if (scrollOverflowHandler.isScrolled(direction, e.target) && scrollOverflowHandler.shouldMovePage()) {
|
|
|
+ // Checking again if we have a scrollable content
|
|
|
+ // To avoid issues like #4479 where the scroll event gets
|
|
|
+ // triggered after removing/hidding content if this was scrolled
|
|
|
+ if (scrollOverflowHandler.shouldBeScrollable(getState().activeSection.item)) {
|
|
|
+ EventEmitter.emit(events.onScrollOverflowScrolled, {
|
|
|
+ direction: direction
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ };
|
|
|
+ }()
|
|
|
+ };
|
|
|
+
|
|
|
+ var g_afterSlideLoadsId;
|
|
|
+ FP.landscapeScroll = landscapeScroll;
|
|
|
+ EventEmitter.on(events.bindEvents, bindEvents$a);
|
|
|
+
|
|
|
+ function bindEvents$a() {
|
|
|
+ EventEmitter.on(events.onPerformMovement, onPerformMovement);
|
|
|
+ }
|
|
|
+
|
|
|
+ function onPerformMovement() {
|
|
|
+ clearTimeout(g_afterSlideLoadsId);
|
|
|
+ setState({
|
|
|
+ slideMoving: false
|
|
|
+ });
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Scrolls horizontal sliders.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function landscapeScroll(slides, destiny, direction) {
|
|
|
+ var sectionElem = closest(slides, SECTION_SEL);
|
|
|
+ var section = getState().sections.filter(function (section) {
|
|
|
+ return section.item == sectionElem;
|
|
|
+ })[0];
|
|
|
+ var slide = section.slides.filter(function (slide) {
|
|
|
+ return slide.item == destiny;
|
|
|
+ })[0];
|
|
|
+ var v = {
|
|
|
+ "slides": slides,
|
|
|
+ "destiny": destiny,
|
|
|
+ "direction": direction,
|
|
|
+ "destinyPos": {
|
|
|
+ "left": destiny.offsetLeft
|
|
|
+ },
|
|
|
+ "slideIndex": slide.index(),
|
|
|
+ "section": sectionElem,
|
|
|
+ "sectionIndex": section.index(),
|
|
|
+ "anchorLink": section.anchor,
|
|
|
+ "slidesNav": $(SLIDES_NAV_SEL, sectionElem)[0],
|
|
|
+ "slideAnchor": slide.anchor,
|
|
|
+ "prevSlide": section.activeSlide.item,
|
|
|
+ "prevSlideIndex": section.activeSlide.index(),
|
|
|
+ "items": {
|
|
|
+ "section": section,
|
|
|
+ "origin": section.activeSlide,
|
|
|
+ "destination": slide
|
|
|
+ },
|
|
|
+ //caching the value of isResizing at the momment the function is called
|
|
|
+ //because it will be checked later inside a setTimeout and the value might change
|
|
|
+ "localIsResizing": state.isResizing
|
|
|
+ };
|
|
|
+ v.xMovement = getXmovement(v.prevSlideIndex, v.slideIndex);
|
|
|
+ v.direction = v.direction ? v.direction : v.xMovement; //important!! Only do it when not resizing
|
|
|
+
|
|
|
+ if (!v.localIsResizing) {
|
|
|
+ //preventing from scrolling to the next/prev section when using scrollHorizontally
|
|
|
+ setState({
|
|
|
+ canScroll: false
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ if (getOptions().onSlideLeave) {
|
|
|
+ //if the site is not just resizing and readjusting the slides
|
|
|
+ if (!v.localIsResizing && v.xMovement !== 'none') {
|
|
|
+ if (isFunction(getOptions().onSlideLeave)) {
|
|
|
+ if (fireCallback('onSlideLeave', v) === false) {
|
|
|
+ setState({
|
|
|
+ slideMoving: false
|
|
|
+ });
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ addClass(destiny, ACTIVE);
|
|
|
+ removeClass(siblings(destiny), ACTIVE);
|
|
|
+ updateState();
|
|
|
+
|
|
|
+ if (!v.localIsResizing) {
|
|
|
+ stopMedia(v.prevSlide);
|
|
|
+ lazyLoad(destiny);
|
|
|
+ }
|
|
|
+
|
|
|
+ toggleControlArrows(v); //only changing the URL if the slides are in the current section (not for resize re-adjusting)
|
|
|
+
|
|
|
+ if (section.isActive && !v.localIsResizing) {
|
|
|
+ setPageStatus(v.slideIndex, v.slideAnchor, v.anchorLink);
|
|
|
+ }
|
|
|
+
|
|
|
+ EventEmitter.emit(events.onSlideLeave, v);
|
|
|
+ performHorizontalMove(slides, v, true);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Performs the horizontal movement. (CSS3 or jQuery)
|
|
|
+ *
|
|
|
+ * @param fireCallback {Boolean} - determines whether or not to fire the callback
|
|
|
+ */
|
|
|
+
|
|
|
+ function performHorizontalMove(slides, v, fireCallback) {
|
|
|
+ var destinyPos = v.destinyPos;
|
|
|
+ activeSlidesNavigation(v.slidesNav, v.slideIndex);
|
|
|
+ setState({
|
|
|
+ scrollX: Math.round(destinyPos.left)
|
|
|
+ });
|
|
|
+
|
|
|
+ if (getOptions().css3) {
|
|
|
+ var translate3d = 'translate3d(-' + Math.round(destinyPos.left) + 'px, 0px, 0px)';
|
|
|
+ FP.test.translate3dH[v.sectionIndex] = translate3d;
|
|
|
+ css(addAnimation($(SLIDES_CONTAINER_SEL, slides)), getTransforms(translate3d));
|
|
|
+ clearTimeout(g_afterSlideLoadsId);
|
|
|
+ g_afterSlideLoadsId = setTimeout(function () {
|
|
|
+ if (fireCallback) {
|
|
|
+ afterSlideLoads(v);
|
|
|
+ }
|
|
|
+ }, getOptions().scrollingSpeed);
|
|
|
+ } else {
|
|
|
+ FP.test.left[v.sectionIndex] = Math.round(destinyPos.left);
|
|
|
+ scrollTo(slides, Math.round(destinyPos.left), getOptions().scrollingSpeed, function () {
|
|
|
+ if (fireCallback) {
|
|
|
+ afterSlideLoads(v);
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Retuns `right` or `left` depending on the scrolling movement to reach its destination
|
|
|
+ * from the current slide.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function getXmovement(fromIndex, toIndex) {
|
|
|
+ if (fromIndex == toIndex) {
|
|
|
+ return 'none';
|
|
|
+ }
|
|
|
+
|
|
|
+ if (fromIndex > toIndex) {
|
|
|
+ return 'left';
|
|
|
+ }
|
|
|
+
|
|
|
+ return 'right';
|
|
|
+ }
|
|
|
+
|
|
|
+ function onDestroy$6() {
|
|
|
+ clearTimeout(g_afterSlideLoadsId);
|
|
|
+ }
|
|
|
+
|
|
|
+ function afterSlideLoads(v) {
|
|
|
+ //if the site is not just resizing and readjusting the slides
|
|
|
+ if (!v.localIsResizing) {
|
|
|
+ if (isFunction(getOptions().afterSlideLoad)) {
|
|
|
+ fireCallback('afterSlideLoad', v);
|
|
|
+ } //needs to be inside the condition to prevent problems with continuousVertical and scrollHorizontally
|
|
|
+ //and to prevent double scroll right after a windows resize
|
|
|
+
|
|
|
+
|
|
|
+ setState({
|
|
|
+ canScroll: true
|
|
|
+ });
|
|
|
+ playMedia(v.destiny);
|
|
|
+ EventEmitter.emit(events.afterSlideLoads, v);
|
|
|
+ } //letting them slide again
|
|
|
+
|
|
|
+
|
|
|
+ setState({
|
|
|
+ slideMoving: false
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Slides silently (with no animation) the active slider to the given slide.
|
|
|
+ * @param noCallback {bool} true or defined -> no callbacks
|
|
|
+ */
|
|
|
+
|
|
|
+ function silentLandscapeScroll(activeSlide, noCallbacks) {
|
|
|
+ setScrollingSpeed(0, 'internal');
|
|
|
+
|
|
|
+ if (typeof noCallbacks !== 'undefined') {
|
|
|
+ //preventing firing callbacks afterSlideLoad etc.
|
|
|
+ setState({
|
|
|
+ isResizing: true
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ landscapeScroll(closest(activeSlide, SLIDES_WRAPPER_SEL), activeSlide);
|
|
|
+
|
|
|
+ if (typeof noCallbacks !== 'undefined') {
|
|
|
+ setState({
|
|
|
+ isResizing: false
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ setScrollingSpeed(getOriginals().scrollingSpeed, 'internal');
|
|
|
+ }
|
|
|
+
|
|
|
+ var g_prevActiveSectionIndex = null;
|
|
|
+ var g_prevActiveSlideIndex = null;
|
|
|
+ /**
|
|
|
+ * Updates the state of the app.
|
|
|
+ */
|
|
|
+
|
|
|
+ function updateState() {
|
|
|
+ state.activeSection = null;
|
|
|
+ state.sections.map(function (section) {
|
|
|
+ var isActive = hasClass(section.item, ACTIVE);
|
|
|
+ section.isActive = isActive;
|
|
|
+ section.hasScroll = scrollOverflowHandler.hasScroll(section.item);
|
|
|
+
|
|
|
+ if (isActive) {
|
|
|
+ state.activeSection = section;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (section.slides.length) {
|
|
|
+ section.activeSlide = null;
|
|
|
+ section.slides.map(function (slide) {
|
|
|
+ var isActiveSlide = hasClass(slide.item, ACTIVE);
|
|
|
+ slide.hasScroll = scrollOverflowHandler.hasScroll(section.item);
|
|
|
+ slide.isActive = isActiveSlide;
|
|
|
+
|
|
|
+ if (isActiveSlide) {
|
|
|
+ section.activeSlide = slide;
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+ });
|
|
|
+ scrollToNewActivePanel();
|
|
|
+ }
|
|
|
+ function updateStructuralState() {
|
|
|
+ var allSectionItems = $(getOptions().sectionSelector, getContainer());
|
|
|
+ var sectionsItems = getVisible(allSectionItems);
|
|
|
+ var allSections = Array.from(allSectionItems).map(function (item) {
|
|
|
+ return new SectionPanel(item);
|
|
|
+ });
|
|
|
+ var sections = allSections.filter(function (item) {
|
|
|
+ return item.isVisible;
|
|
|
+ });
|
|
|
+ var slides = sections.reduce(function (acc, section) {
|
|
|
+ return acc.concat(section.slides);
|
|
|
+ }, []); // keeping track of the previously active section
|
|
|
+
|
|
|
+ g_prevActiveSectionIndex = getPrevActivePanelIndex(state.activeSection);
|
|
|
+ g_prevActiveSlideIndex = getPrevActivePanelIndex(state.activeSection ? state.activeSection.activeSlide : null);
|
|
|
+ state.numSections = sectionsItems.length;
|
|
|
+ state.numSlides = sections.reduce(function (acc, section) {
|
|
|
+ return acc + section.slides.length;
|
|
|
+ }, 0);
|
|
|
+ state.sections = sections;
|
|
|
+ state.sectionsIncludingHidden = allSections;
|
|
|
+ state.slides = slides;
|
|
|
+ state.panels = state.sections.concat(state.slides);
|
|
|
+ }
|
|
|
+
|
|
|
+ function getPrevActivePanelIndex(activePanel) {
|
|
|
+ if (!activePanel) {
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ var prevActivePanelItem = activePanel ? activePanel.item : null;
|
|
|
+ var hiddenPanels = activePanel.isSection ? state.sectionsIncludingHidden : state.activeSection.slidesIncludingHidden;
|
|
|
+
|
|
|
+ if (prevActivePanelItem) {
|
|
|
+ var panel = getPanelByElement(hiddenPanels, prevActivePanelItem);
|
|
|
+ return panel ? panel.index() : null;
|
|
|
+ }
|
|
|
+
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * When changes in the DOM take place there's a change
|
|
|
+ * the active section is now hidden or removed.
|
|
|
+ * fullPage.js will scroll to the closest section nearby.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function scrollToNewActivePanel() {
|
|
|
+ var activeSection = state.activeSection;
|
|
|
+ var activeSectionHasSlides = state.activeSection ? state.activeSection.slides.length : false;
|
|
|
+ var activeSlide = state.activeSection ? state.activeSection.activeSlide : null; // Hidding / removing the active section ?
|
|
|
+
|
|
|
+ if (!activeSection && state.sections.length && !getState().isBeyondFullpage && g_prevActiveSectionIndex) {
|
|
|
+ var newActiveSection = getNewActivePanel(g_prevActiveSectionIndex, state.sections);
|
|
|
+
|
|
|
+ if (newActiveSection) {
|
|
|
+ state.activeSection = newActiveSection;
|
|
|
+ state.activeSection.isActive = true;
|
|
|
+ addClass(state.activeSection.item, ACTIVE);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (state.activeSection) {
|
|
|
+ silentScroll(state.activeSection.item.offsetTop);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (activeSectionHasSlides && !activeSlide && g_prevActiveSlideIndex) {
|
|
|
+ var newActiveSlide = getNewActivePanel(g_prevActiveSlideIndex, state.activeSection.slides);
|
|
|
+
|
|
|
+ if (newActiveSlide) {
|
|
|
+ state.activeSection.activeSlide = newActiveSlide;
|
|
|
+ state.activeSection.activeSlide.isActive = true;
|
|
|
+ addClass(state.activeSection.activeSlide.item, ACTIVE);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (state.activeSection.activeSlide) {
|
|
|
+ silentLandscapeScroll(state.activeSection.activeSlide.item, 'internal');
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function getNewActivePanel(prevActivePanelIndex, siblings) {
|
|
|
+ var newActiveSection;
|
|
|
+ var prevIndex = prevActivePanelIndex - 1;
|
|
|
+ var nextIndex = prevActivePanelIndex;
|
|
|
+
|
|
|
+ do {
|
|
|
+ newActiveSection = siblings[prevIndex] || siblings[nextIndex];
|
|
|
+
|
|
|
+ if (newActiveSection) {
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ prevIndex = prevIndex - 1;
|
|
|
+ nextIndex = nextIndex + 1;
|
|
|
+ } while (prevIndex >= 0 || nextIndex < siblings.length);
|
|
|
+
|
|
|
+ return newActiveSection;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Section object
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ var SectionPanel = function SectionPanel(el) {
|
|
|
+ var _this = this;
|
|
|
+
|
|
|
+ [].push.call(arguments, getOptions().sectionSelector);
|
|
|
+ Item.apply(this, arguments);
|
|
|
+ this.allSlidesItems = $(getOptions().slideSelector, el);
|
|
|
+ this.slidesIncludingHidden = Array.from(this.allSlidesItems).map(function (item) {
|
|
|
+ return new SlidePanel(item, _this);
|
|
|
+ });
|
|
|
+ this.slides = this.slidesIncludingHidden.filter(function (slidePanel) {
|
|
|
+ return slidePanel.isVisible;
|
|
|
+ });
|
|
|
+ this.activeSlide = this.slides.length ? this.slides.filter(function (slide) {
|
|
|
+ return slide.isActive;
|
|
|
+ })[0] || this.slides[0] : null;
|
|
|
+ };
|
|
|
+ SectionPanel.prototype = Item.prototype;
|
|
|
+ SectionPanel.prototype.constructor = SectionPanel;
|
|
|
+ /**
|
|
|
+ * Slide object
|
|
|
+ */
|
|
|
+
|
|
|
+ var SlidePanel = function SlidePanel(el, section) {
|
|
|
+ this.parent = section;
|
|
|
+ Item.call(this, el, getOptions().slideSelector);
|
|
|
+ };
|
|
|
+
|
|
|
+ SlidePanel.prototype = Item.prototype;
|
|
|
+ SlidePanel.prototype.constructor = SectionPanel;
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Adds internal classes to be able to provide customizable selectors
|
|
|
+ * keeping the link with the style sheet.
|
|
|
+ */
|
|
|
+
|
|
|
+ function addInternalSelectors() {
|
|
|
+ addClass($(getOptions().sectionSelector, getContainer()), SECTION);
|
|
|
+ addClass($(getOptions().slideSelector, getContainer()), SLIDE);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Styles the horizontal slides for a section.
|
|
|
+ */
|
|
|
+
|
|
|
+ function styleSlides(section) {
|
|
|
+ var numSlides = section.slides.length;
|
|
|
+ var slidesElems = section.allSlidesItems;
|
|
|
+ var slides = section.slides;
|
|
|
+ var sliderWidth = numSlides * 100;
|
|
|
+ var slideWidth = 100 / numSlides;
|
|
|
+
|
|
|
+ if (!$(SLIDES_WRAPPER_SEL, section.item)[0]) {
|
|
|
+ var slidesWrapper = doc.createElement('div');
|
|
|
+ slidesWrapper.className = SLIDES_WRAPPER; //fp-slides
|
|
|
+
|
|
|
+ wrapAll(slidesElems, slidesWrapper);
|
|
|
+ var slidesContainer = doc.createElement('div');
|
|
|
+ slidesContainer.className = SLIDES_CONTAINER; //fp-slidesContainer
|
|
|
+
|
|
|
+ wrapAll(slidesElems, slidesContainer);
|
|
|
+ }
|
|
|
+
|
|
|
+ css($(SLIDES_CONTAINER_SEL, section.item), {
|
|
|
+ 'width': sliderWidth + '%'
|
|
|
+ });
|
|
|
+
|
|
|
+ if (numSlides > 1) {
|
|
|
+ if (getOptions().controlArrows) {
|
|
|
+ createSlideArrows(section);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (getOptions().slidesNavigation) {
|
|
|
+ addSlidesNavigation(section);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ slides.forEach(function (slide) {
|
|
|
+ css(slide.item, {
|
|
|
+ 'width': slideWidth + '%'
|
|
|
+ });
|
|
|
+
|
|
|
+ if (getOptions().verticalCentered) {
|
|
|
+ addTableClass(slide);
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var startingSlide = section.activeSlide || null; //if the slide won't be an starting point, the default will be the first one
|
|
|
+ //the active section isn't the first one? Is not the first slide of the first section? Then we load that section/slide by default.
|
|
|
+
|
|
|
+ if (startingSlide != null && state.activeSection && (state.activeSection.index() !== 0 || state.activeSection.index() === 0 && startingSlide.index() !== 0)) {
|
|
|
+ silentLandscapeScroll(startingSlide.item, 'internal');
|
|
|
+ } else {
|
|
|
+ addClass(slidesElems[0], ACTIVE);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var g_wrapperObserver;
|
|
|
+ var g_wrapperObserveConfig = {
|
|
|
+ attributes: false,
|
|
|
+ subtree: true,
|
|
|
+ childList: true,
|
|
|
+ characterData: true
|
|
|
+ };
|
|
|
+ EventEmitter.on(events.bindEvents, bindEvents$9);
|
|
|
+ FP["render"] = onContentChange;
|
|
|
+
|
|
|
+ function bindEvents$9() {
|
|
|
+ if (getOptions().observer && "MutationObserver" in window && $(WRAPPER_SEL)[0]) {
|
|
|
+ g_wrapperObserver = createObserver($(WRAPPER_SEL)[0], onContentChange, g_wrapperObserveConfig);
|
|
|
+ }
|
|
|
+
|
|
|
+ EventEmitter.on(events.contentChanged, onContentChange);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Creates a Mutation observer.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function createObserver(target, callback, config) {
|
|
|
+ var observer = new MutationObserver(callback);
|
|
|
+ observer.observe(target, config);
|
|
|
+ return observer;
|
|
|
+ }
|
|
|
+
|
|
|
+ function didSlidesChange() {
|
|
|
+ return getVisible($(getOptions().slideSelector, getContainer())).length !== getState().numSlides;
|
|
|
+ }
|
|
|
+
|
|
|
+ function didSectionsChange() {
|
|
|
+ return getVisible($(getOptions().sectionSelector, getContainer())).length !== getState().numSections;
|
|
|
+ }
|
|
|
+
|
|
|
+ function didSectionsOrSlidesChange() {
|
|
|
+ return didSlidesChange() || didSectionsChange();
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Listen to changes on sections and fires reBuild
|
|
|
+ * when those changes affect the section height.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function onContentChange(mutations) {
|
|
|
+ var _didSlidesChange = didSlidesChange();
|
|
|
+
|
|
|
+ if (didSectionsOrSlidesChange() && !state.isDoingContinousVertical) {
|
|
|
+ if (getOptions().observer && g_wrapperObserver) {
|
|
|
+ // Temporally disabling the observer while
|
|
|
+ // we modidy the DOM again
|
|
|
+ g_wrapperObserver.disconnect();
|
|
|
+ }
|
|
|
+
|
|
|
+ updateStructuralState();
|
|
|
+ updateState(); // Removing navs and anchors options
|
|
|
+
|
|
|
+ getOptions().anchors = [];
|
|
|
+ remove($(SECTION_NAV_SEL));
|
|
|
+ addInternalSelectors();
|
|
|
+ setOptionsFromDOM();
|
|
|
+
|
|
|
+ if (getOptions().navigation) {
|
|
|
+ addVerticalNavigation();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (_didSlidesChange) {
|
|
|
+ remove($(SLIDES_NAV_SEL));
|
|
|
+ remove($(SLIDES_ARROW_SEL));
|
|
|
+ }
|
|
|
+
|
|
|
+ getState().sections.forEach(function (section) {
|
|
|
+ if (section.slides.length) {
|
|
|
+ if (_didSlidesChange) {
|
|
|
+ styleSlides(section);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ styleSection(section);
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ if (getOptions().observer && g_wrapperObserver && $(WRAPPER_SEL)[0]) {
|
|
|
+ g_wrapperObserver.observe($(WRAPPER_SEL)[0], g_wrapperObserveConfig);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var supportsPassiveEvents = function () {
|
|
|
+ //cheks for passive event support
|
|
|
+ var g_supportsPassive = false;
|
|
|
+
|
|
|
+ try {
|
|
|
+ var opts = Object.defineProperty({}, 'passive', {
|
|
|
+ get: function get() {
|
|
|
+ g_supportsPassive = true;
|
|
|
+ }
|
|
|
+ });
|
|
|
+ windowAddEvent("testPassive", null, opts);
|
|
|
+ windowRemoveEvent("testPassive", null, opts);
|
|
|
+ } catch (e) {}
|
|
|
+
|
|
|
+ return function () {
|
|
|
+ return g_supportsPassive;
|
|
|
+ };
|
|
|
+ }();
|
|
|
+
|
|
|
+ function getPassiveOptionsIfPossible() {
|
|
|
+ return supportsPassiveEvents() ? {
|
|
|
+ passive: false
|
|
|
+ } : false;
|
|
|
+ }
|
|
|
+
|
|
|
+ var wheelDataHandler = function () {
|
|
|
+ var _prevTime = new Date().getTime();
|
|
|
+
|
|
|
+ var _scrollings = [];
|
|
|
+ var isScrollingVertically;
|
|
|
+ var direction;
|
|
|
+ return {
|
|
|
+ registerEvent: function registerEvent(e) {
|
|
|
+ e = e || win.event;
|
|
|
+ var value = e.wheelDelta || -e.deltaY || -e.detail;
|
|
|
+ var delta = Math.max(-1, Math.min(1, value));
|
|
|
+ var horizontalDetection = typeof e.wheelDeltaX !== 'undefined' || typeof e.deltaX !== 'undefined';
|
|
|
+ isScrollingVertically = Math.abs(e.wheelDeltaX) < Math.abs(e.wheelDelta) || Math.abs(e.deltaX) < Math.abs(e.deltaY) || !horizontalDetection;
|
|
|
+ var curTime = new Date().getTime();
|
|
|
+ direction = delta < 0 ? 'down' : 'up'; //Limiting the array to 150 (lets not waste memory!)
|
|
|
+
|
|
|
+ if (_scrollings.length > 149) {
|
|
|
+ _scrollings.shift();
|
|
|
+ } //keeping record of the previous scrollings
|
|
|
+
|
|
|
+
|
|
|
+ _scrollings.push(Math.abs(value)); //time difference between the last scroll and the current one
|
|
|
+
|
|
|
+
|
|
|
+ var timeDiff = curTime - _prevTime;
|
|
|
+ _prevTime = curTime; //haven't they scrolled in a while?
|
|
|
+ //(enough to be consider a different scrolling action to scroll another section)
|
|
|
+
|
|
|
+ if (timeDiff > 200) {
|
|
|
+ //emptying the array, we dont care about old scrollings for our averages
|
|
|
+ _scrollings = [];
|
|
|
+ }
|
|
|
+ },
|
|
|
+ isAccelerating: function isAccelerating() {
|
|
|
+ var averageEnd = getAverage(_scrollings, 10);
|
|
|
+ var averageMiddle = getAverage(_scrollings, 70);
|
|
|
+ var isAccelerating = averageEnd >= averageMiddle;
|
|
|
+ return _scrollings.length ? isAccelerating && isScrollingVertically : false;
|
|
|
+ },
|
|
|
+ getDirection: function getDirection() {
|
|
|
+ return direction;
|
|
|
+ }
|
|
|
+ };
|
|
|
+ }();
|
|
|
+
|
|
|
+ function scrollBeyondFullPage() {
|
|
|
+ var dtop = getDestinationOffset();
|
|
|
+ var scrollSettings = getScrollSettings(dtop);
|
|
|
+ FP.test.top = -dtop + 'px';
|
|
|
+ setState({
|
|
|
+ canScroll: false
|
|
|
+ });
|
|
|
+ scrollTo(scrollSettings.element, scrollSettings.options, getOptions().scrollingSpeed, function () {
|
|
|
+ setTimeout(function () {
|
|
|
+ setState({
|
|
|
+ isBeyondFullpage: true
|
|
|
+ });
|
|
|
+ setState({
|
|
|
+ canScroll: true
|
|
|
+ });
|
|
|
+ }, 30);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ function onKeyDown() {
|
|
|
+ if (!isFullPageAbove()) {
|
|
|
+ return;
|
|
|
+ } else {
|
|
|
+ scrollUpToFullpage();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ function scrollUpToFullpage() {
|
|
|
+ var scrollSettings = getScrollSettings(getLast(getState().sections).item.offsetTop);
|
|
|
+ setState({
|
|
|
+ canScroll: false
|
|
|
+ });
|
|
|
+ scrollTo(scrollSettings.element, scrollSettings.options, getOptions().scrollingSpeed, function () {
|
|
|
+ setState({
|
|
|
+ canScroll: true
|
|
|
+ });
|
|
|
+ setState({
|
|
|
+ isBeyondFullpage: false
|
|
|
+ });
|
|
|
+ setState({
|
|
|
+ isAboutToScrollToFullPage: false
|
|
|
+ });
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ function getDestinationOffset() {
|
|
|
+ if (!getOptions().css3) {
|
|
|
+ return getLast(getState().sections).item.offsetTop + getLast(getState().sections).item.offsetHeight;
|
|
|
+ }
|
|
|
+
|
|
|
+ return getScrollTop() + getWindowHeight();
|
|
|
+ }
|
|
|
+
|
|
|
+ function beyondFullPageHandler(container, e) {
|
|
|
+ new Date().getTime();
|
|
|
+ var pauseScroll = getState().isBeyondFullpage && container.getBoundingClientRect().bottom >= 0 && wheelDataHandler.getDirection() === 'up';
|
|
|
+ var g_isAboutToScrollToFullPage = getState().isAboutToScrollToFullPage;
|
|
|
+
|
|
|
+ if (g_isAboutToScrollToFullPage) {
|
|
|
+ preventDefault(e);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (getState().isBeyondFullpage) {
|
|
|
+ if (!pauseScroll) {
|
|
|
+ keyframeTime('set', 'beyondFullpage', 1000);
|
|
|
+ } else {
|
|
|
+ var shouldSetFixedPosition = !g_isAboutToScrollToFullPage && (!keyframeTime('isNewKeyframe', 'beyondFullpage') || !wheelDataHandler.isAccelerating());
|
|
|
+ var scrollSettings;
|
|
|
+
|
|
|
+ if (shouldSetFixedPosition) {
|
|
|
+ scrollSettings = getScrollSettings(getLast(getState().sections).item.offsetTop + getLast(getState().sections).item.offsetHeight);
|
|
|
+ scrollSettings.element.scrollTo(0, scrollSettings.options);
|
|
|
+ setState({
|
|
|
+ isAboutToScrollToFullPage: false
|
|
|
+ });
|
|
|
+ preventDefault(e);
|
|
|
+ return false;
|
|
|
+ } else if (wheelDataHandler.isAccelerating()) {
|
|
|
+ pauseScroll = false;
|
|
|
+ setState({
|
|
|
+ isAboutToScrollToFullPage: true
|
|
|
+ });
|
|
|
+ setState({
|
|
|
+ scrollTrigger: 'wheel'
|
|
|
+ });
|
|
|
+ scrollUpToFullpage();
|
|
|
+ preventDefault(e);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!g_isAboutToScrollToFullPage) {
|
|
|
+ // allow normal scrolling, but quitting
|
|
|
+ if (!pauseScroll) {
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var keyframeTime = function () {
|
|
|
+ var isNew = false;
|
|
|
+ var frames = {};
|
|
|
+ var timeframes = {};
|
|
|
+ return function (action, name, timeframe) {
|
|
|
+ switch (action) {
|
|
|
+ case 'set':
|
|
|
+ frames[name] = new Date().getTime();
|
|
|
+ timeframes[name] = timeframe;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case 'isNewKeyframe':
|
|
|
+ var current = new Date().getTime();
|
|
|
+ isNew = current - frames[name] > timeframes[name];
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ return isNew;
|
|
|
+ };
|
|
|
+ }();
|
|
|
+
|
|
|
+ FP.moveSectionDown = moveSectionDown;
|
|
|
+ /**
|
|
|
+ * Moves the page down one section.
|
|
|
+ */
|
|
|
+
|
|
|
+ function moveSectionDown() {
|
|
|
+ var next = getState().activeSection.next(); //looping to the top if there's no more sections below
|
|
|
+
|
|
|
+ if (!next && (getOptions().loopBottom || getOptions().continuousVertical)) {
|
|
|
+ next = getState().sections[0];
|
|
|
+ }
|
|
|
+
|
|
|
+ if (next != null) {
|
|
|
+ scrollPage(next, null, false);
|
|
|
+ } else if (hasContentBeyondFullPage()) {
|
|
|
+ EventEmitter.emit(events.scrollBeyondFullpage);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function hasContentBeyondFullPage() {
|
|
|
+ return getContainer().scrollHeight < $body.scrollHeight && getOptions().scrollBar && getOptions().scrollBeyondFullpage;
|
|
|
+ }
|
|
|
+
|
|
|
+ FP.moveSectionUp = moveSectionUp;
|
|
|
+ /**
|
|
|
+ * Moves the page up one section.
|
|
|
+ */
|
|
|
+
|
|
|
+ function moveSectionUp() {
|
|
|
+ var prev = getState().activeSection.prev(); //looping to the bottom if there's no more sections above
|
|
|
+
|
|
|
+ if (!prev && (getOptions().loopTop || getOptions().continuousVertical)) {
|
|
|
+ prev = getLast(getState().sections);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (prev != null) {
|
|
|
+ scrollPage(prev, null, true);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var oldPageY = 0;
|
|
|
+ /**
|
|
|
+ * Detecting the direction of the mouse movement.
|
|
|
+ * Used only for the middle button of the mouse.
|
|
|
+ */
|
|
|
+
|
|
|
+ function mouseMoveHandler(e) {
|
|
|
+ if (!getOptions().autoScrolling) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (state.canScroll) {
|
|
|
+ // moving up
|
|
|
+ if (e.pageY < oldPageY && getIsScrollAllowed().m.up) {
|
|
|
+ moveSectionUp();
|
|
|
+ } // moving down
|
|
|
+ else if (e.pageY > oldPageY && getIsScrollAllowed().m.down) {
|
|
|
+ moveSectionDown();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ oldPageY = e.pageY;
|
|
|
+ }
|
|
|
+ function setOldPageY(value) {
|
|
|
+ oldPageY = value;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Determines the way of scrolling up or down:
|
|
|
+ * by 'automatically' scrolling a section or by using the default and normal scrolling.
|
|
|
+ */
|
|
|
+
|
|
|
+ function scrolling(type) {
|
|
|
+ if (!getIsScrollAllowed().m[type]) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ var scrollSection = type === 'down' ? moveSectionDown : moveSectionUp;
|
|
|
+
|
|
|
+ if (getOptions().scrollOverflow && scrollOverflowHandler.isScrollable(getState().activeSection)) {
|
|
|
+ //is the scrollbar at the start/end of the scroll?
|
|
|
+ if (scrollOverflowHandler.isScrolled(type, getState().activeSection.item) && scrollOverflowHandler.shouldMovePage()) {
|
|
|
+ scrollSection();
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ scrollSection();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var touchStartY = 0;
|
|
|
+ var touchStartX = 0;
|
|
|
+ var touchEndY = 0;
|
|
|
+ var touchEndX = 0;
|
|
|
+ var MSPointer = getMSPointer();
|
|
|
+ var pointers = {
|
|
|
+ touchmove: 'ontouchmove' in window ? 'touchmove' : MSPointer ? MSPointer.move : null,
|
|
|
+ touchstart: 'ontouchstart' in window ? 'touchstart' : MSPointer ? MSPointer.down : null
|
|
|
+ };
|
|
|
+ /**
|
|
|
+ * Adds the possibility to auto scroll through sections on touch devices.
|
|
|
+ */
|
|
|
+
|
|
|
+ function addTouchHandler() {
|
|
|
+ if (!pointers.touchmove) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (isTouchDevice || isTouch) {
|
|
|
+ if (getOptions().autoScrolling) {
|
|
|
+ $body.removeEventListener(pointers.touchmove, preventBouncing, {
|
|
|
+ passive: false
|
|
|
+ });
|
|
|
+ $body.addEventListener(pointers.touchmove, preventBouncing, {
|
|
|
+ passive: false
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ var touchWrapper = getOptions().touchWrapper;
|
|
|
+ touchWrapper.removeEventListener(pointers.touchstart, touchStartHandler);
|
|
|
+ touchWrapper.removeEventListener(pointers.touchmove, touchMoveHandler, {
|
|
|
+ passive: false
|
|
|
+ });
|
|
|
+ touchWrapper.addEventListener(pointers.touchstart, touchStartHandler);
|
|
|
+ touchWrapper.addEventListener(pointers.touchmove, touchMoveHandler, {
|
|
|
+ passive: false
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Removes the auto scrolling for touch devices.
|
|
|
+ */
|
|
|
+
|
|
|
+ function removeTouchHandler() {
|
|
|
+ if (!pointers.touchmove) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (isTouchDevice || isTouch) {
|
|
|
+ // normalScrollElements requires it off #2691
|
|
|
+ if (getOptions().autoScrolling) {
|
|
|
+ $body.removeEventListener(pointers.touchmove, touchMoveHandler, {
|
|
|
+ passive: false
|
|
|
+ });
|
|
|
+ $body.removeEventListener(pointers.touchmove, preventBouncing, {
|
|
|
+ passive: false
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ var touchWrapper = getOptions().touchWrapper;
|
|
|
+ touchWrapper.removeEventListener(pointers.touchstart, touchStartHandler);
|
|
|
+ touchWrapper.removeEventListener(pointers.touchmove, touchMoveHandler, {
|
|
|
+ passive: false
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /* Detecting touch events
|
|
|
+
|
|
|
+ * As we are changing the top property of the page on scrolling, we can not use the traditional way to detect it.
|
|
|
+ * This way, the touchstart and the touch moves shows an small difference between them which is the
|
|
|
+ * used one to determine the direction.
|
|
|
+ */
|
|
|
+
|
|
|
+ function touchMoveHandler(e) {
|
|
|
+ var activeSection = closest(e.target, SECTION_SEL) || getState().activeSection.item;
|
|
|
+ var hasActiveSectionOverflow = scrollOverflowHandler.isScrollable(getState().activeSection);
|
|
|
+
|
|
|
+ if (isReallyTouch(e)) {
|
|
|
+ setState({
|
|
|
+ isGrabbing: true,
|
|
|
+ isUsingWheel: false
|
|
|
+ });
|
|
|
+
|
|
|
+ if (getOptions().autoScrolling) {
|
|
|
+ if (hasActiveSectionOverflow && !state.canScroll || getOptions().scrollBar) {
|
|
|
+ //preventing the easing on iOS devices
|
|
|
+ preventDefault(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var touchEvents = getEventsPage(e);
|
|
|
+ touchEndY = touchEvents.y;
|
|
|
+ touchEndX = touchEvents.x;
|
|
|
+ var isVerticalMovementEnough = Math.abs(touchStartY - touchEndY) > win.innerHeight / 100 * getOptions().touchSensitivity;
|
|
|
+ var isHorizontalMovementEnough = Math.abs(touchStartX - touchEndX) > getWindowWidth() / 100 * getOptions().touchSensitivity;
|
|
|
+ var isHorizontalPredominantMove = $(SLIDES_WRAPPER_SEL, activeSection).length && Math.abs(touchStartX - touchEndX) > Math.abs(touchStartY - touchEndY);
|
|
|
+ var directionH = touchStartX > touchEndX ? 'right' : 'left';
|
|
|
+ var directionV = touchStartY > touchEndY ? 'down' : 'up';
|
|
|
+ var direction = isHorizontalPredominantMove ? directionH : directionV;
|
|
|
+ setState({
|
|
|
+ touchDirection: direction
|
|
|
+ }); //if movement in the X axys is greater than in the Y and the currect section has slides...
|
|
|
+
|
|
|
+ if (isHorizontalPredominantMove) {
|
|
|
+ //is the movement greater than the minimum resistance to scroll?
|
|
|
+ if (!state.slideMoving && isHorizontalMovementEnough) {
|
|
|
+ if (touchStartX > touchEndX) {
|
|
|
+ if (getIsScrollAllowed().m.right) {
|
|
|
+ EventEmitter.emit(events.moveSlideRight, {
|
|
|
+ section: activeSection
|
|
|
+ });
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (getIsScrollAllowed().m.left) {
|
|
|
+ EventEmitter.emit(events.moveSlideLeft, {
|
|
|
+ section: activeSection
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } //vertical scrolling (only when autoScrolling is enabled)
|
|
|
+ else if (getOptions().autoScrolling && state.canScroll) {
|
|
|
+ //is the movement greater than the minimum resistance to scroll?
|
|
|
+ if (isVerticalMovementEnough) {
|
|
|
+ scrolling(directionV);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * As IE >= 10 fires both touch and mouse events when using a mouse in a touchscreen
|
|
|
+ * this way we make sure that is really a touch event what IE is detecting.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function isReallyTouch(e) {
|
|
|
+ //if is not IE || IE is detecting `touch` or `pen`
|
|
|
+ return typeof e.pointerType === 'undefined' || e.pointerType != 'mouse';
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Handler for the touch start event.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function touchStartHandler(e) {
|
|
|
+ //stopping the auto scroll to adjust to a section
|
|
|
+ if (getOptions().fitToSection) {
|
|
|
+ setState({
|
|
|
+ activeAnimation: false
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ if (isReallyTouch(e)) {
|
|
|
+ var touchEvents = getEventsPage(e);
|
|
|
+ touchStartY = touchEvents.y;
|
|
|
+ touchStartX = touchEvents.x;
|
|
|
+ }
|
|
|
+
|
|
|
+ windowAddEvent('touchend', touchEndHandler);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Handler for the touch end event.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function touchEndHandler() {
|
|
|
+ windowRemoveEvent('touchend', touchEndHandler);
|
|
|
+ setState({
|
|
|
+ isGrabbing: false
|
|
|
+ });
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets the pageX and pageY properties depending on the browser.
|
|
|
+ * https://github.com/alvarotrigo/fullPage.js/issues/194#issuecomment-34069854
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function getEventsPage(e) {
|
|
|
+ var events = {};
|
|
|
+ events.y = typeof e.pageY !== 'undefined' && (e.pageY || e.pageX) ? e.pageY : e.touches[0].pageY;
|
|
|
+ events.x = typeof e.pageX !== 'undefined' && (e.pageY || e.pageX) ? e.pageX : e.touches[0].pageX; //in touch devices with scrollBar:true, e.pageY is detected, but we have to deal with touch events. #1008
|
|
|
+
|
|
|
+ if (isTouch && isReallyTouch(e) && getOptions().scrollBar && typeof e.touches !== 'undefined') {
|
|
|
+ events.y = e.touches[0].pageY;
|
|
|
+ events.x = e.touches[0].pageX;
|
|
|
+ }
|
|
|
+
|
|
|
+ return events;
|
|
|
+ }
|
|
|
+ /*
|
|
|
+ * Returns and object with Microsoft pointers (for IE<11 and for IE >= 11)
|
|
|
+ * http://msdn.microsoft.com/en-us/library/ie/dn304886(v=vs.85).aspx
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function getMSPointer() {
|
|
|
+ var pointer; //IE >= 11 & rest of browsers
|
|
|
+
|
|
|
+ if (win.PointerEvent) {
|
|
|
+ pointer = {
|
|
|
+ down: 'pointerdown',
|
|
|
+ move: 'pointermove'
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ return pointer;
|
|
|
+ }
|
|
|
+ /*
|
|
|
+ * Preventing bouncing in iOS #2285
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function preventBouncing(e) {
|
|
|
+ if (getOptions().autoScrolling && isReallyTouch(e) && getIsScrollAllowed().m.up) {
|
|
|
+ //preventing the easing on iOS devices
|
|
|
+ if (!state.canScroll) {
|
|
|
+ preventDefault(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ FP.moveSlideLeft = moveSlideLeft;
|
|
|
+ FP.moveSlideRight = moveSlideRight;
|
|
|
+ /**
|
|
|
+ * Slides a slider to the given direction.
|
|
|
+ * Optional `section` param.
|
|
|
+ */
|
|
|
+
|
|
|
+ function moveSlide(direction, section) {
|
|
|
+ var activeSectionItem = section == null ? getState().activeSection.item : section;
|
|
|
+ var activeSection = getPanelByElement(state.sections, activeSectionItem);
|
|
|
+ var slides = $(SLIDES_WRAPPER_SEL, activeSectionItem)[0]; // more than one slide needed and nothing should be sliding
|
|
|
+
|
|
|
+ if (slides == null || state.slideMoving || activeSection.slides.length < 2) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ var currentSlide = activeSection.activeSlide;
|
|
|
+ var destiny = direction === 'left' ? currentSlide.prev() : currentSlide.next(); //isn't there a next slide in the secuence?
|
|
|
+
|
|
|
+ if (!destiny) {
|
|
|
+ //respect loopHorizontal setting
|
|
|
+ if (!getOptions().loopHorizontal) return;
|
|
|
+ destiny = direction === 'left' ? getLast(activeSection.slides) : activeSection.slides[0];
|
|
|
+ }
|
|
|
+
|
|
|
+ setState({
|
|
|
+ slideMoving: !FP.test.isTesting
|
|
|
+ });
|
|
|
+ landscapeScroll(slides, destiny.item, direction);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Slides left the slider of the active section.
|
|
|
+ * Optional `section` param.
|
|
|
+ */
|
|
|
+
|
|
|
+ function moveSlideLeft(section) {
|
|
|
+ moveSlide('left', section);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Slides right the slider of the active section.
|
|
|
+ * Optional `section` param.
|
|
|
+ */
|
|
|
+
|
|
|
+ function moveSlideRight(section) {
|
|
|
+ moveSlide('right', section);
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Gets a section by its anchor / index
|
|
|
+ */
|
|
|
+
|
|
|
+ function getSectionByAnchor(sectionAnchor) {
|
|
|
+ var section = getState().sections.filter(function (section) {
|
|
|
+ return section.anchor === sectionAnchor;
|
|
|
+ })[0];
|
|
|
+
|
|
|
+ if (!section) {
|
|
|
+ var sectionIndex = typeof sectionAnchor !== 'undefined' ? sectionAnchor - 1 : 0;
|
|
|
+ section = getState().sections[sectionIndex];
|
|
|
+ }
|
|
|
+
|
|
|
+ return section;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Scrolls the slider to the given slide destination for the given section
|
|
|
+ */
|
|
|
+
|
|
|
+ function scrollSlider(slideElem) {
|
|
|
+ if (slideElem != null) {
|
|
|
+ landscapeScroll(closest(slideElem, SLIDES_WRAPPER_SEL), slideElem);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Scrolls to the given section and slide anchors
|
|
|
+ */
|
|
|
+
|
|
|
+ function scrollPageAndSlide(sectionAnchor, slideAnchor) {
|
|
|
+ var section = getSectionByAnchor(sectionAnchor); //do nothing if there's no section with the given anchor name
|
|
|
+
|
|
|
+ if (section == null) return;
|
|
|
+ var slideElem = getSlideByAnchor(slideAnchor, section); //we need to scroll to the section and then to the slide
|
|
|
+
|
|
|
+ if ((!section.anchor || section.anchor !== state.lastScrolledDestiny) && !hasClass(section.item, ACTIVE)) {
|
|
|
+ scrollPage(section, function () {
|
|
|
+ scrollSlider(slideElem);
|
|
|
+ });
|
|
|
+ } //if we were already in the section
|
|
|
+ else {
|
|
|
+ scrollSlider(slideElem);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets a slide inside a given section by its anchor / index
|
|
|
+ */
|
|
|
+
|
|
|
+ function getSlideByAnchor(slideAnchor, section) {
|
|
|
+ var slide = section.slides.filter(function (slide) {
|
|
|
+ return slide.anchor === slideAnchor;
|
|
|
+ })[0];
|
|
|
+
|
|
|
+ if (slide == null) {
|
|
|
+ slideAnchor = typeof slideAnchor !== 'undefined' ? slideAnchor : 0;
|
|
|
+ slide = section.slides[slideAnchor];
|
|
|
+ }
|
|
|
+
|
|
|
+ return slide ? slide.item : null;
|
|
|
+ }
|
|
|
+
|
|
|
+ FP.moveTo = moveTo$1;
|
|
|
+ /**
|
|
|
+ * Moves the page to the given section and slide.
|
|
|
+ * Anchors or index positions can be used as params.
|
|
|
+ */
|
|
|
+
|
|
|
+ function moveTo$1(sectionAnchor, slideAnchor) {
|
|
|
+ var destiny = getSectionByAnchor(sectionAnchor);
|
|
|
+
|
|
|
+ if (typeof slideAnchor !== 'undefined') {
|
|
|
+ scrollPageAndSlide(sectionAnchor, slideAnchor);
|
|
|
+ } else if (destiny != null) {
|
|
|
+ scrollPage(destiny);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ //@ts-check
|
|
|
+ var g_controlPressed;
|
|
|
+ var g_keydownId;
|
|
|
+ var g_elToFocus;
|
|
|
+ EventEmitter.on(events.bindEvents, bindEvents$8);
|
|
|
+
|
|
|
+ function bindEvents$8() {
|
|
|
+ //when opening a new tab (ctrl + t), `control` won't be pressed when coming back.
|
|
|
+ windowAddEvent('blur', blurHandler); //Sliding with arrow keys, both, vertical and horizontal
|
|
|
+
|
|
|
+ docAddEvent('keydown', keydownHandler); //to prevent scrolling while zooming
|
|
|
+
|
|
|
+ docAddEvent('keyup', keyUpHandler);
|
|
|
+ EventEmitter.on(events.onDestroy, onDestroy$5);
|
|
|
+ EventEmitter.on(events.afterSlideLoads, onAfterSlideLoads);
|
|
|
+ EventEmitter.on(events.afterSectionLoads, afterSectionLoads);
|
|
|
+ }
|
|
|
+
|
|
|
+ function onDestroy$5() {
|
|
|
+ clearTimeout(g_keydownId);
|
|
|
+ docRemoveEvent('keydown', keydownHandler);
|
|
|
+ docRemoveEvent('keyup', keyUpHandler);
|
|
|
+ } //Sliding with arrow keys, both, vertical and horizontal
|
|
|
+
|
|
|
+
|
|
|
+ function keydownHandler(e) {
|
|
|
+ clearTimeout(g_keydownId);
|
|
|
+ var keyCode = e.keyCode;
|
|
|
+ var isPressingHorizontalArrows = [37, 39].indexOf(keyCode) > -1;
|
|
|
+ var canScrollWithKeyboard = getOptions().autoScrolling || getOptions().fitToSection || isPressingHorizontalArrows; //tab?
|
|
|
+
|
|
|
+ if (keyCode === 9) {
|
|
|
+ onTab(e);
|
|
|
+ } else if (!isInsideInput() && getOptions().keyboardScrolling && canScrollWithKeyboard) {
|
|
|
+ g_controlPressed = e.ctrlKey;
|
|
|
+ g_keydownId = setTimeout(function () {
|
|
|
+ onkeydown(e);
|
|
|
+ }, 0);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Keydown event
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function onkeydown(e) {
|
|
|
+ var shiftPressed = e.shiftKey;
|
|
|
+ var activeElement = doc.activeElement;
|
|
|
+ var isMediaFocused = matches(activeElement, 'video') || matches(activeElement, 'audio');
|
|
|
+ var isScrolled = {
|
|
|
+ up: scrollOverflowHandler.isScrolled('up', getState().activeSection.item),
|
|
|
+ down: scrollOverflowHandler.isScrolled('down', getState().activeSection.item)
|
|
|
+ };
|
|
|
+ var isUsingHorizontalArrowKeys = [37, 39].indexOf(e.keyCode) > -1;
|
|
|
+ cancelDirectionKeyEvents(e); //do nothing if we can not scroll or we are not using horizotnal key arrows.
|
|
|
+
|
|
|
+ if (!state.canScroll && !isUsingHorizontalArrowKeys) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ setState({
|
|
|
+ scrollTrigger: 'keydown'
|
|
|
+ });
|
|
|
+
|
|
|
+ switch (e.keyCode) {
|
|
|
+ //up
|
|
|
+ case 38:
|
|
|
+ case 33:
|
|
|
+ if (getIsScrollAllowed().k.up && isScrolled.up) {
|
|
|
+ if (state.isBeyondFullpage) {
|
|
|
+ EventEmitter.emit(events.onKeyDown, {
|
|
|
+ e: e
|
|
|
+ });
|
|
|
+ } else {
|
|
|
+ moveSectionUp();
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ scrollOverflowHandler.focusScrollable();
|
|
|
+ }
|
|
|
+
|
|
|
+ break;
|
|
|
+ //down
|
|
|
+
|
|
|
+ case 32:
|
|
|
+ //spacebar
|
|
|
+ if (shiftPressed && getIsScrollAllowed().k.up && !isMediaFocused && isScrolled.up) {
|
|
|
+ moveSectionUp();
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* falls through */
|
|
|
+
|
|
|
+ case 40:
|
|
|
+ case 34:
|
|
|
+ if (getIsScrollAllowed().k.down && isScrolled.down) {
|
|
|
+ if (state.isBeyondFullpage) {
|
|
|
+ return;
|
|
|
+ } // space bar?
|
|
|
+
|
|
|
+
|
|
|
+ if (e.keyCode !== 32 || !isMediaFocused) {
|
|
|
+ moveSectionDown();
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ scrollOverflowHandler.focusScrollable();
|
|
|
+ }
|
|
|
+
|
|
|
+ break;
|
|
|
+ //Home
|
|
|
+
|
|
|
+ case 36:
|
|
|
+ if (getIsScrollAllowed().k.up) {
|
|
|
+ moveTo$1(1);
|
|
|
+ }
|
|
|
+
|
|
|
+ break;
|
|
|
+ //End
|
|
|
+
|
|
|
+ case 35:
|
|
|
+ if (getIsScrollAllowed().k.down) {
|
|
|
+ moveTo$1(getState().sections.length);
|
|
|
+ }
|
|
|
+
|
|
|
+ break;
|
|
|
+ //left
|
|
|
+
|
|
|
+ case 37:
|
|
|
+ if (getIsScrollAllowed().k.left) {
|
|
|
+ moveSlideLeft();
|
|
|
+ }
|
|
|
+
|
|
|
+ break;
|
|
|
+ //right
|
|
|
+
|
|
|
+ case 39:
|
|
|
+ if (getIsScrollAllowed().k.right) {
|
|
|
+ moveSlideRight();
|
|
|
+ }
|
|
|
+
|
|
|
+ break;
|
|
|
+
|
|
|
+ default:
|
|
|
+ return;
|
|
|
+ // exit this handler for other keys
|
|
|
+ }
|
|
|
+ } //to prevent scrolling while zooming
|
|
|
+
|
|
|
+
|
|
|
+ function keyUpHandler(e) {
|
|
|
+ if (state.isWindowFocused) {
|
|
|
+ //the keyup gets fired on new tab ctrl + t in Firefox
|
|
|
+ g_controlPressed = e.ctrlKey;
|
|
|
+ }
|
|
|
+ } //when opening a new tab (ctrl + t), `control` won't be pressed when coming back.
|
|
|
+
|
|
|
+
|
|
|
+ function blurHandler() {
|
|
|
+ setState({
|
|
|
+ isWindowFocused: false
|
|
|
+ });
|
|
|
+ g_controlPressed = false;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Makes sure the tab key will only focus elements within the current section/slide
|
|
|
+ * preventing this way from breaking the page.
|
|
|
+ * Based on "Modals and keyboard traps"
|
|
|
+ * from https://developers.google.com/web/fundamentals/accessibility/focus/using-tabindex
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function onTab(e) {
|
|
|
+ var isShiftPressed = e.shiftKey;
|
|
|
+ var activeElement = doc.activeElement;
|
|
|
+ var focusableElements = getFocusables(getSlideOrSection(getState().activeSection.item));
|
|
|
+
|
|
|
+ function preventAndFocusFirst(e) {
|
|
|
+ preventDefault(e);
|
|
|
+ return focusableElements[0] ? focusableElements[0].focus() : null;
|
|
|
+ } // deactivating tab while scrolling #4550
|
|
|
+
|
|
|
+
|
|
|
+ if (!state.canScroll) {
|
|
|
+ preventDefault(e);
|
|
|
+ return;
|
|
|
+ } //outside any section or slide? Let's not hijack the tab!
|
|
|
+
|
|
|
+
|
|
|
+ if (isFocusOutside(e)) {
|
|
|
+ return;
|
|
|
+ } //is there an element with focus?
|
|
|
+
|
|
|
+
|
|
|
+ if (activeElement) {
|
|
|
+ if (closest(activeElement, SECTION_ACTIVE_SEL + ',' + SECTION_ACTIVE_SEL + ' ' + SLIDE_ACTIVE_SEL) == null) {
|
|
|
+ activeElement = preventAndFocusFirst(e);
|
|
|
+ }
|
|
|
+ } //no element if focused? Let's focus the first one of the section/slide
|
|
|
+ else {
|
|
|
+ preventAndFocusFirst(e);
|
|
|
+ } //when reached the first or last focusable element of the section/slide
|
|
|
+ //we prevent the tab action to keep it in the last focusable element
|
|
|
+
|
|
|
+
|
|
|
+ var isFirstFocusableInSection = activeElement == focusableElements[0];
|
|
|
+ var isLastFocusableInSection = activeElement == focusableElements[focusableElements.length - 1];
|
|
|
+ var isNextItem = !isShiftPressed && isLastFocusableInSection;
|
|
|
+ var isPrevItem = isShiftPressed && isFirstFocusableInSection;
|
|
|
+
|
|
|
+ if (isPrevItem || isNextItem) {
|
|
|
+ preventDefault(e);
|
|
|
+ var focusInfo = getPanelWithFocusable(isPrevItem);
|
|
|
+ var destinationPanel = focusInfo ? focusInfo.panel : null;
|
|
|
+
|
|
|
+ if (destinationPanel) {
|
|
|
+ var destinationSection = destinationPanel.isSection ? destinationPanel : destinationPanel.parent;
|
|
|
+ EventEmitter.emit(events.onScrollPageAndSlide, {
|
|
|
+ sectionAnchor: destinationSection.index() + 1,
|
|
|
+ slideAnchor: destinationPanel.isSection ? 0 : destinationPanel.index()
|
|
|
+ });
|
|
|
+ g_elToFocus = focusInfo.itemToFocus;
|
|
|
+ preventDefault(e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function onAfterSlideLoads(v) {
|
|
|
+ focusItem();
|
|
|
+ }
|
|
|
+
|
|
|
+ function afterSectionLoads(v) {
|
|
|
+ if (!closest(g_elToFocus, SLIDE_SEL) || closest(g_elToFocus, SLIDE_ACTIVE_SEL)) {
|
|
|
+ focusItem();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function focusItem() {
|
|
|
+ if (g_elToFocus) {
|
|
|
+ g_elToFocus.focus();
|
|
|
+ g_elToFocus = null;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Get's the panel containing the element to focus.
|
|
|
+ *
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function getPanelWithFocusable(isPrevItem) {
|
|
|
+ var action = isPrevItem ? 'prevPanel' : 'nextPanel';
|
|
|
+ var focusableElements = [];
|
|
|
+ var panelWithFocusables;
|
|
|
+ var currentPanel = getSlideOrSectionPanel(getActivePanel()[action]());
|
|
|
+
|
|
|
+ do {
|
|
|
+ focusableElements = getFocusables(currentPanel.item);
|
|
|
+
|
|
|
+ if (focusableElements.length) {
|
|
|
+ panelWithFocusables = {
|
|
|
+ panel: currentPanel,
|
|
|
+ itemToFocus: focusableElements[isPrevItem ? focusableElements.length - 1 : 0]
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ currentPanel = getSlideOrSectionPanel(currentPanel[action]());
|
|
|
+ } while (currentPanel && focusableElements.length === 0);
|
|
|
+
|
|
|
+ return panelWithFocusables;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets all the focusable elements inside the passed element.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function getFocusables(el) {
|
|
|
+ return [].slice.call($(focusableElementsString, el)).filter(function (item) {
|
|
|
+ return getAttr(item, 'tabindex') !== '-1' && //are also not hidden elements (or with hidden parents)
|
|
|
+ item.offsetParent !== null;
|
|
|
+ });
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Determines whether the focus is outside fullpage.js sections/slides or not.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function isFocusOutside(e) {
|
|
|
+ var allFocusables = getFocusables(doc);
|
|
|
+ var currentFocusIndex = allFocusables.indexOf(doc.activeElement);
|
|
|
+ var focusDestinationIndex = e.shiftKey ? currentFocusIndex - 1 : currentFocusIndex + 1;
|
|
|
+ var focusDestination = allFocusables[focusDestinationIndex];
|
|
|
+ var destinationItemSlide = closest(focusDestination, SLIDE_SEL);
|
|
|
+ var destinationItemSection = closest(focusDestination, SECTION_SEL);
|
|
|
+ return !destinationItemSlide && !destinationItemSection;
|
|
|
+ }
|
|
|
+
|
|
|
+ function shouldCancelKeyboardNavigation(e) {
|
|
|
+ // https://keycode.info/for/34
|
|
|
+ // 40 = arrow down
|
|
|
+ // 38 = arrow up
|
|
|
+ // 32 = spacebar
|
|
|
+ // 33 = PageUp
|
|
|
+ // 34 = PageDown
|
|
|
+ var keyControls = [40, 38, 32, 33, 34];
|
|
|
+ return keyControls.indexOf(e.keyCode) > -1 && !state.isBeyondFullpage;
|
|
|
+ } //preventing the scroll with arrow keys & spacebar & Page Up & Down keys
|
|
|
+
|
|
|
+
|
|
|
+ function cancelDirectionKeyEvents(e) {
|
|
|
+ if (shouldCancelKeyboardNavigation(e) && !closest(e.target, OVERFLOW_SEL)) {
|
|
|
+ e.preventDefault();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function getControlPressed() {
|
|
|
+ return g_controlPressed;
|
|
|
+ }
|
|
|
+
|
|
|
+ var prevTime = new Date().getTime();
|
|
|
+ var scrollings = [];
|
|
|
+ FP.setMouseWheelScrolling = setMouseWheelScrolling;
|
|
|
+ /**
|
|
|
+ * Adds or remove the possibility of scrolling through sections by using the mouse wheel or the trackpad.
|
|
|
+ */
|
|
|
+
|
|
|
+ function setMouseWheelScrolling(value) {
|
|
|
+ if (value) {
|
|
|
+ addMouseWheelHandler();
|
|
|
+ addMiddleWheelHandler();
|
|
|
+ } else {
|
|
|
+ removeMouseWheelHandler();
|
|
|
+ removeMiddleWheelHandler();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Adds the auto scrolling action for the mouse wheel and trackpad.
|
|
|
+ * After this function is called, the mousewheel and trackpad movements will scroll through sections
|
|
|
+ * https://developer.mozilla.org/en-US/docs/Web/Events/wheel
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function addMouseWheelHandler() {
|
|
|
+ var prefix = '';
|
|
|
+
|
|
|
+ var _addEventListener;
|
|
|
+
|
|
|
+ if (win.addEventListener) {
|
|
|
+ _addEventListener = "addEventListener";
|
|
|
+ } else {
|
|
|
+ _addEventListener = "attachEvent";
|
|
|
+ prefix = 'on';
|
|
|
+ } // detect available wheel event
|
|
|
+
|
|
|
+
|
|
|
+ var support = 'onwheel' in doc.createElement('div') ? 'wheel' : // Modern browsers support "wheel"
|
|
|
+ // @ts-ignore
|
|
|
+ doc.onmousewheel !== undefined ? 'mousewheel' : // Webkit and IE support at least "mousewheel"
|
|
|
+ 'DOMMouseScroll'; // let's assume that remaining browsers are older Firefox
|
|
|
+
|
|
|
+ var passiveEvent = getPassiveOptionsIfPossible();
|
|
|
+
|
|
|
+ if (support == 'DOMMouseScroll') {
|
|
|
+ doc[_addEventListener](prefix + 'MozMousePixelScroll', MouseWheelHandler, passiveEvent);
|
|
|
+ } //handle MozMousePixelScroll in older Firefox
|
|
|
+ else {
|
|
|
+ doc[_addEventListener](prefix + support, MouseWheelHandler, passiveEvent);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Binding the mousemove when the mouse's middle button is pressed
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function addMiddleWheelHandler() {
|
|
|
+ getContainer().addEventListener('mousedown', mouseDownHandler);
|
|
|
+ getContainer().addEventListener('mouseup', mouseUpHandler);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Removes the auto scrolling action fired by the mouse wheel and trackpad.
|
|
|
+ * After this function is called, the mousewheel and trackpad movements won't scroll through sections.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function removeMouseWheelHandler() {
|
|
|
+ if (doc.addEventListener) {
|
|
|
+ docRemoveEvent('mousewheel', MouseWheelHandler, false); //IE9, Chrome, Safari, Oper
|
|
|
+
|
|
|
+ docRemoveEvent('wheel', MouseWheelHandler, false); //Firefox
|
|
|
+
|
|
|
+ docRemoveEvent('MozMousePixelScroll', MouseWheelHandler, false); //old Firefox
|
|
|
+ } else {
|
|
|
+ // @ts-ignore
|
|
|
+ doc.detachEvent('onmousewheel', MouseWheelHandler); //IE 6/7/8
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Unbinding the mousemove when the mouse's middle button is released
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function removeMiddleWheelHandler() {
|
|
|
+ getContainer().removeEventListener('mousedown', mouseDownHandler);
|
|
|
+ getContainer().removeEventListener('mouseup', mouseUpHandler);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Detecting mousewheel scrolling
|
|
|
+ *
|
|
|
+ * http://blogs.sitepointstatic.com/examples/tech/mouse-wheel/index.html
|
|
|
+ * http://www.sitepoint.com/html5-javascript-mouse-wheel/
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function MouseWheelHandler(e) {
|
|
|
+ var curTime = new Date().getTime();
|
|
|
+ var isNormalScroll = hasClass($(COMPLETELY_SEL)[0], NORMAL_SCROLL);
|
|
|
+ var isScrollAllowedBeyondFullPage = beyondFullPageHandler(getContainer(), e);
|
|
|
+
|
|
|
+ if (!state.isUsingWheel) {
|
|
|
+ setState({
|
|
|
+ isGrabbing: false,
|
|
|
+ isUsingWheel: true,
|
|
|
+ touchDirection: 'none'
|
|
|
+ });
|
|
|
+ } //is scroll allowed?
|
|
|
+
|
|
|
+
|
|
|
+ if (!getIsScrollAllowed().m.down && !getIsScrollAllowed().m.up) {
|
|
|
+ preventDefault(e);
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (isScrollAllowedBeyondFullPage) {
|
|
|
+ return true;
|
|
|
+ } else if (isScrollAllowedBeyondFullPage === false) {
|
|
|
+ preventDefault(e);
|
|
|
+ return false;
|
|
|
+ } //autoscrolling and not zooming?
|
|
|
+
|
|
|
+
|
|
|
+ if (getOptions().autoScrolling && !getControlPressed() && !isNormalScroll) {
|
|
|
+ // cross-browser wheel delta
|
|
|
+ e = e || win.event;
|
|
|
+ var value = e.wheelDelta || -e.deltaY || -e.detail;
|
|
|
+ var delta = Math.max(-1, Math.min(1, value));
|
|
|
+ var horizontalDetection = typeof e.wheelDeltaX !== 'undefined' || typeof e.deltaX !== 'undefined';
|
|
|
+ var isScrollingVertically = Math.abs(e.wheelDeltaX) < Math.abs(e.wheelDelta) || Math.abs(e.deltaX) < Math.abs(e.deltaY) || !horizontalDetection;
|
|
|
+ var direction = delta < 0 ? 'down' : delta > 0 ? 'up' : 'none'; //Limiting the array to 150 (lets not waste memory!)
|
|
|
+
|
|
|
+ if (scrollings.length > 149) {
|
|
|
+ scrollings.shift();
|
|
|
+ } //keeping record of the previous scrollings
|
|
|
+
|
|
|
+
|
|
|
+ scrollings.push(Math.abs(value)); //preventing to scroll the site on mouse wheel when scrollbar is present
|
|
|
+
|
|
|
+ if (getOptions().scrollBar) {
|
|
|
+ preventDefault(e);
|
|
|
+ } //time difference between the last scroll and the current one
|
|
|
+
|
|
|
+
|
|
|
+ var timeDiff = curTime - prevTime;
|
|
|
+ prevTime = curTime; //haven't they scrolled in a while?
|
|
|
+ //(enough to be consider a different scrolling action to scroll another section)
|
|
|
+
|
|
|
+ if (timeDiff > 200) {
|
|
|
+ //emptying the array, we dont care about old scrollings for our averages
|
|
|
+ scrollings = [];
|
|
|
+ }
|
|
|
+
|
|
|
+ setState({
|
|
|
+ wheelDirection: direction
|
|
|
+ });
|
|
|
+
|
|
|
+ if (state.canScroll) {
|
|
|
+ var averageEnd = getAverage(scrollings, 10);
|
|
|
+ var averageMiddle = getAverage(scrollings, 70);
|
|
|
+ var isAccelerating = averageEnd >= averageMiddle; //to avoid double swipes...
|
|
|
+
|
|
|
+ if (isAccelerating && isScrollingVertically) {
|
|
|
+ setState({
|
|
|
+ scrollTrigger: 'wheel'
|
|
|
+ }); //scrolling down?
|
|
|
+
|
|
|
+ if (delta < 0) {
|
|
|
+ scrolling('down');
|
|
|
+ } //scrolling up?
|
|
|
+ else {
|
|
|
+ scrolling('up');
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (getOptions().fitToSection) {
|
|
|
+ //stopping the auto scroll to adjust to a section
|
|
|
+ setState({
|
|
|
+ activeAnimation: false
|
|
|
+ });
|
|
|
+ }
|
|
|
+ } //binding the mousemove when the mouse's middle button is released
|
|
|
+
|
|
|
+
|
|
|
+ function mouseDownHandler(e) {
|
|
|
+ //middle button
|
|
|
+ if (e.which == 2) {
|
|
|
+ setOldPageY(e.pageY);
|
|
|
+ getContainer().addEventListener('mousemove', mouseMoveHandler);
|
|
|
+ }
|
|
|
+ } //unbinding the mousemove when the mouse's middle button is released
|
|
|
+
|
|
|
+
|
|
|
+ function mouseUpHandler(e) {
|
|
|
+ //middle button
|
|
|
+ if (e.which == 2) {
|
|
|
+ getContainer().removeEventListener('mousemove', mouseMoveHandler);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Adds or remove the mouse wheel hijacking
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function setMouseHijack(value) {
|
|
|
+ if (value) {
|
|
|
+ setMouseWheelScrolling(true);
|
|
|
+ addTouchHandler();
|
|
|
+ } else {
|
|
|
+ setMouseWheelScrolling(false);
|
|
|
+ removeTouchHandler();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var g_canFireMouseEnterNormalScroll = true;
|
|
|
+ EventEmitter.on(events.bindEvents, bindEvents$7);
|
|
|
+
|
|
|
+ function bindEvents$7() {
|
|
|
+ /**
|
|
|
+ * Applying normalScroll elements.
|
|
|
+ * Ignoring the scrolls over the specified selectors.
|
|
|
+ */
|
|
|
+ if (getOptions().normalScrollElements) {
|
|
|
+ ['mouseenter', 'touchstart'].forEach(function (eventName) {
|
|
|
+ forMouseLeaveOrTouch(eventName, false);
|
|
|
+ });
|
|
|
+ ['mouseleave', 'touchend'].forEach(function (eventName) {
|
|
|
+ forMouseLeaveOrTouch(eventName, true);
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ EventEmitter.on(events.onDestroy, onDestroy$4);
|
|
|
+ }
|
|
|
+
|
|
|
+ function onDestroy$4() {
|
|
|
+ ['mouseenter', 'touchstart', 'mouseleave', 'touchend'].forEach(function (eventName) {
|
|
|
+ docRemoveEvent(eventName, onMouseEnterOrLeave, true); //true is required!
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ function forMouseLeaveOrTouch(eventName, allowScrolling) {
|
|
|
+ //a way to pass arguments to the onMouseEnterOrLeave function
|
|
|
+ document['fp_' + eventName] = allowScrolling;
|
|
|
+ docAddEvent(eventName, onMouseEnterOrLeave, true); //capturing phase
|
|
|
+ }
|
|
|
+
|
|
|
+ function onMouseEnterOrLeave(e) {
|
|
|
+ var type = e.type;
|
|
|
+ var isInsideOneNormalScroll = false; //onMouseLeave will use the destination target, not the one we are moving away from
|
|
|
+
|
|
|
+ var target = type === 'mouseleave' ? e.toElement || e.relatedTarget : e.target; //coming from closing a normalScrollElements modal or moving outside viewport?
|
|
|
+
|
|
|
+ if (target == document || !target) {
|
|
|
+ setMouseHijack(true);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (type === 'touchend') {
|
|
|
+ g_canFireMouseEnterNormalScroll = false;
|
|
|
+ setTimeout(function () {
|
|
|
+ g_canFireMouseEnterNormalScroll = true;
|
|
|
+ }, 800);
|
|
|
+ } //preventing mouseenter event to do anything when coming from a touchEnd event
|
|
|
+ //fixing issue #3576
|
|
|
+
|
|
|
+
|
|
|
+ if (type === 'mouseenter' && !g_canFireMouseEnterNormalScroll) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ var normalSelectors = getOptions().normalScrollElements.split(',');
|
|
|
+ normalSelectors.forEach(function (normalSelector) {
|
|
|
+ if (!isInsideOneNormalScroll) {
|
|
|
+ var isNormalScrollTarget = matches(target, normalSelector); //leaving a child inside the normalScoll element is not leaving the normalScroll #3661
|
|
|
+
|
|
|
+ var isNormalScrollChildFocused = closest(target, normalSelector);
|
|
|
+
|
|
|
+ if (isNormalScrollTarget || isNormalScrollChildFocused) {
|
|
|
+ if (!FP.shared.isNormalScrollElement) {
|
|
|
+ setMouseHijack(false);
|
|
|
+ }
|
|
|
+
|
|
|
+ FP.shared.isNormalScrollElement = true;
|
|
|
+ isInsideOneNormalScroll = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }); //not inside a single normal scroll element anymore?
|
|
|
+
|
|
|
+ if (!isInsideOneNormalScroll && FP.shared.isNormalScrollElement) {
|
|
|
+ setMouseHijack(true);
|
|
|
+ FP.shared.isNormalScrollElement = false;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ FP.silentMoveTo = silentMoveTo;
|
|
|
+ /**
|
|
|
+ * Moves the page to the given section and slide with no animation.
|
|
|
+ * Anchors or index positions can be used as params.
|
|
|
+ */
|
|
|
+
|
|
|
+ function silentMoveTo(sectionAnchor, slideAnchor) {
|
|
|
+ setScrollingSpeed(0, 'internal');
|
|
|
+ moveTo$1(sectionAnchor, slideAnchor);
|
|
|
+ setScrollingSpeed(getOriginals().scrollingSpeed, 'internal');
|
|
|
+ }
|
|
|
+
|
|
|
+ var previousHeight = getWindowHeight();
|
|
|
+ var windowsWidth = getWindowWidth();
|
|
|
+ var g_resizeId;
|
|
|
+ var g_isConsecutiveResize = false;
|
|
|
+ var g_resizeMobileHandlerId;
|
|
|
+ FP.reBuild = reBuild;
|
|
|
+ EventEmitter.on(events.bindEvents, bindEvents$6);
|
|
|
+
|
|
|
+ function bindEvents$6() {
|
|
|
+ // Setting VH correctly in mobile devices
|
|
|
+ resizeHandler(); //when resizing the site, we adjust the heights of the sections, slimScroll...
|
|
|
+
|
|
|
+ windowAddEvent('resize', resizeHandler);
|
|
|
+ EventEmitter.on(events.onDestroy, onDestroy$3);
|
|
|
+ }
|
|
|
+
|
|
|
+ function onDestroy$3() {
|
|
|
+ clearTimeout(g_resizeId);
|
|
|
+ clearTimeout(g_resizeMobileHandlerId);
|
|
|
+ windowRemoveEvent('resize', resizeHandler);
|
|
|
+ }
|
|
|
+ /*
|
|
|
+ * Resize event handler.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function resizeHandler() {
|
|
|
+ if (!g_isConsecutiveResize) {
|
|
|
+ if (getOptions().autoScrolling && !getOptions().scrollBar || !getOptions().fitToSection) {
|
|
|
+ setSectionsHeight(getWindowHeight());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ fitToActiveSection();
|
|
|
+ g_isConsecutiveResize = true; //in order to call the functions only when the resize is finished
|
|
|
+ //http://stackoverflow.com/questions/4298612/jquery-how-to-call-resize-event-only-once-its-finished-resizing
|
|
|
+
|
|
|
+ clearTimeout(g_resizeId);
|
|
|
+ g_resizeId = setTimeout(function () {
|
|
|
+ //issue #3336
|
|
|
+ //(some apps or browsers, like Chrome/Firefox for Mobile take time to report the real height)
|
|
|
+ //so we check it 3 times with intervals in that case
|
|
|
+ // for(var i = 0; i< 4; i++){
|
|
|
+ resizeActions();
|
|
|
+ g_isConsecutiveResize = false; // }
|
|
|
+ }, 400);
|
|
|
+ }
|
|
|
+
|
|
|
+ function fitToActiveSection() {
|
|
|
+ if (isTouchDevice) {
|
|
|
+ // Issue #4393 and previously in v3, #3336
|
|
|
+ // (some apps or browsers, like Chrome/Firefox will delay a bit to scroll
|
|
|
+ // to the focused input
|
|
|
+ for (var i = 0; i < 4; i++) {
|
|
|
+ g_resizeMobileHandlerId = setTimeout(function () {
|
|
|
+ window.requestAnimationFrame(function () {
|
|
|
+ // on Android devices the browser scrolls to the focused element
|
|
|
+ // messing up the whole page structure. So we need to update the
|
|
|
+ // translate3d value when the keyboard shows/hides
|
|
|
+ if (getOptions().autoScrolling && !getOptions().scrollBar) {
|
|
|
+ setState({
|
|
|
+ isResizing: true
|
|
|
+ });
|
|
|
+ silentMoveTo(state.activeSection.index() + 1);
|
|
|
+ setState({
|
|
|
+ isResizing: false
|
|
|
+ });
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }, 200 * i);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * When resizing the site, we adjust the heights of the sections, slimScroll...
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function resizeActions() {
|
|
|
+ setState({
|
|
|
+ isResizing: true
|
|
|
+ });
|
|
|
+ setSectionsHeight('');
|
|
|
+
|
|
|
+ if (!getOptions().autoScrolling && !state.isBeyondFullpage) {
|
|
|
+ setVhUnits();
|
|
|
+ }
|
|
|
+
|
|
|
+ EventEmitter.emit(events.contentChanged);
|
|
|
+ updateState(); //checking if it needs to get responsive
|
|
|
+
|
|
|
+ responsive(); // rebuild immediately on touch devices
|
|
|
+
|
|
|
+ if (isTouchDevice) {
|
|
|
+ var activeElement = doc.activeElement; //if the keyboard is NOT visible
|
|
|
+
|
|
|
+ if (!matches(activeElement, 'textarea') && !matches(activeElement, 'input') && !matches(activeElement, 'select')) {
|
|
|
+ var currentHeight = getWindowHeight(); //making sure the change in the viewport size is enough to force a rebuild. (20 % of the window to avoid problems when hidding scroll bars)
|
|
|
+
|
|
|
+ if (Math.abs(currentHeight - previousHeight) > 20 * Math.max(previousHeight, currentHeight) / 100) {
|
|
|
+ reBuild(true);
|
|
|
+ previousHeight = currentHeight;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ adjustToNewViewport();
|
|
|
+ }
|
|
|
+
|
|
|
+ setState({
|
|
|
+ isResizing: false
|
|
|
+ });
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * When resizing is finished, we adjust the slides sizes and positions
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function reBuild(resizing) {
|
|
|
+ if (hasClass(getContainer(), DESTROYED)) {
|
|
|
+ return;
|
|
|
+ } //nothing to do if the plugin was destroyed
|
|
|
+ //updating global vars
|
|
|
+
|
|
|
+
|
|
|
+ setState({
|
|
|
+ isResizing: true,
|
|
|
+ windowsHeight: getWindowHeight(),
|
|
|
+ windowsWidth: getWindowWidth()
|
|
|
+ });
|
|
|
+ var sections = getState().sections;
|
|
|
+
|
|
|
+ for (var i = 0; i < sections.length; ++i) {
|
|
|
+ var section = sections[i];
|
|
|
+ var slidesWrap = $(SLIDES_WRAPPER_SEL, section.item)[0];
|
|
|
+ var slides = section.slides; //adjusting the position fo the FULL WIDTH slides...
|
|
|
+
|
|
|
+ if (slides.length > 1) {
|
|
|
+ landscapeScroll(slidesWrap, section.activeSlide.item);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (getOptions().scrollOverflow) {
|
|
|
+ scrollOverflowHandler.makeScrollable();
|
|
|
+ }
|
|
|
+
|
|
|
+ var sectionIndex = getState().activeSection.index();
|
|
|
+
|
|
|
+ if (!state.isBeyondFullpage) {
|
|
|
+ //isn't it the first section?
|
|
|
+ if (sectionIndex) {
|
|
|
+ //adjusting the position for the current section
|
|
|
+ silentMoveTo(sectionIndex + 1);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ setState({
|
|
|
+ isResizing: false
|
|
|
+ });
|
|
|
+
|
|
|
+ if (isFunction(getOptions().afterResize) && resizing) {
|
|
|
+ getOptions().afterResize.call(getContainer(), win.innerWidth, win.innerHeight);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (isFunction(getOptions().afterReBuild) && !resizing) {
|
|
|
+ getOptions().afterReBuild.call(getContainer());
|
|
|
+ }
|
|
|
+
|
|
|
+ trigger(getContainer(), 'afterRebuild');
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Adjusts a section to the viewport if it has changed.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function adjustToNewViewport() {
|
|
|
+ var newWindowHeight = getWindowHeight();
|
|
|
+ var newWindowWidth = getWindowWidth();
|
|
|
+
|
|
|
+ if (state.windowsHeight !== newWindowHeight || windowsWidth !== newWindowWidth) {
|
|
|
+ setState({
|
|
|
+ windowsHeight: newWindowHeight
|
|
|
+ });
|
|
|
+ windowsWidth = newWindowWidth;
|
|
|
+ reBuild(true);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function setSectionsHeight(value) {
|
|
|
+ var propertyValue = value === '' ? '' : value + 'px';
|
|
|
+ getState().sections.forEach(function (section) {
|
|
|
+ css(section.item, {
|
|
|
+ 'height': propertyValue
|
|
|
+ });
|
|
|
+ });
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Defining the value in px of a VH unit. (Used for autoScrolling: false)
|
|
|
+ * To fix the height issue on mobile devices when using VH units.
|
|
|
+ * https://css-tricks.com/the-trick-to-viewport-units-on-mobile/
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function setVhUnits() {
|
|
|
+ if (!getOptions().autoScrolling || getOptions().scrollBar) {
|
|
|
+ // First we get the viewport height and we multiple it by 1% to get a value for a vh unit
|
|
|
+ var vh = win.innerHeight * 0.01; // Then we set the value in the --vh custom property to the root of the document
|
|
|
+
|
|
|
+ doc.documentElement.style.setProperty('--vh', "".concat(vh, "px"));
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function getAnchorsURL() {
|
|
|
+ var section;
|
|
|
+ var slide;
|
|
|
+ var hash = win.location.hash;
|
|
|
+
|
|
|
+ if (hash.length) {
|
|
|
+ //getting the anchor link in the URL and deleting the `#`
|
|
|
+ var anchorsParts = hash.replace('#', '').split('/'); //using / for visual reasons and not as a section/slide separator #2803
|
|
|
+
|
|
|
+ var isFunkyAnchor = hash.indexOf('#/') > -1;
|
|
|
+ section = isFunkyAnchor ? '/' + anchorsParts[1] : decodeURIComponent(anchorsParts[0]);
|
|
|
+ var slideAnchor = isFunkyAnchor ? anchorsParts[2] : anchorsParts[1];
|
|
|
+
|
|
|
+ if (slideAnchor && slideAnchor.length) {
|
|
|
+ slide = decodeURIComponent(slideAnchor);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return {
|
|
|
+ section: section,
|
|
|
+ slide: slide
|
|
|
+ };
|
|
|
+ }
|
|
|
+
|
|
|
+ FP.setLockAnchors = setLockAnchors;
|
|
|
+ EventEmitter.on(events.bindEvents, bindEvents$5);
|
|
|
+
|
|
|
+ function bindEvents$5() {
|
|
|
+ //detecting any change on the URL to scroll to the given anchor link
|
|
|
+ //(a way to detect back history button as we play with the hashes on the URL)
|
|
|
+ windowAddEvent('hashchange', hashChangeHandler);
|
|
|
+ EventEmitter.on(events.onDestroy, onDestroy$2);
|
|
|
+ }
|
|
|
+
|
|
|
+ function onDestroy$2() {
|
|
|
+ windowRemoveEvent('hashchange', hashChangeHandler);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Sets lockAnchors
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function setLockAnchors(value) {
|
|
|
+ getOptions().lockAnchors = value;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Detecting any change on the URL to scroll to the given anchor link
|
|
|
+ * (a way to detect back history button as we play with the hashes on the URL)
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function hashChangeHandler() {
|
|
|
+ if (!state.isScrolling && !getOptions().lockAnchors) {
|
|
|
+ var anchors = getAnchorsURL();
|
|
|
+ var sectionAnchor = anchors.section;
|
|
|
+ var slideAnchor = anchors.slide; //when moving to a slide in the first section for the first time (first time to add an anchor to the URL)
|
|
|
+
|
|
|
+ var isFirstSlideMove = typeof state.lastScrolledDestiny === 'undefined';
|
|
|
+ var isFirstScrollMove = typeof state.lastScrolledDestiny === 'undefined' && typeof slideAnchor === 'undefined' && !state.slideMoving;
|
|
|
+
|
|
|
+ if (sectionAnchor && sectionAnchor.length) {
|
|
|
+ /*in order to call scrollpage() only once for each destination at a time
|
|
|
+ It is called twice for each scroll otherwise, as in case of using anchorlinks `hashChange`
|
|
|
+ event is fired on every scroll too.*/
|
|
|
+ if (sectionAnchor && sectionAnchor !== state.lastScrolledDestiny && !isFirstSlideMove || isFirstScrollMove || !state.slideMoving && state.lastScrolledSlide != slideAnchor) {
|
|
|
+ EventEmitter.emit(events.onScrollPageAndSlide, {
|
|
|
+ sectionAnchor: sectionAnchor,
|
|
|
+ slideAnchor: slideAnchor
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ EventEmitter.on(events.bindEvents, bindEvents$4);
|
|
|
+
|
|
|
+ function bindEvents$4() {
|
|
|
+ docAddEvent('wheel', wheelDataHandler.registerEvent, getPassiveOptionsIfPossible());
|
|
|
+ EventEmitter.on(events.scrollBeyondFullpage, scrollBeyondFullPage);
|
|
|
+ EventEmitter.on(events.onKeyDown, onKeyDown);
|
|
|
+ }
|
|
|
+
|
|
|
+ EventEmitter.on(events.bindEvents, bindEvents$3);
|
|
|
+
|
|
|
+ function bindEvents$3() {
|
|
|
+ EventEmitter.on(events.onClickOrTouch, onClickOrTouch$1);
|
|
|
+ }
|
|
|
+
|
|
|
+ function onClickOrTouch$1(params) {
|
|
|
+ var target = params.target;
|
|
|
+
|
|
|
+ if (closest(target, getOptions().menu + ' [data-menuanchor]')) {
|
|
|
+ menuItemsHandler.call(target, params);
|
|
|
+ }
|
|
|
+ } //Menu item handler when not using anchors or using lockAnchors:true
|
|
|
+
|
|
|
+
|
|
|
+ function menuItemsHandler(e) {
|
|
|
+ setState({
|
|
|
+ scrollTrigger: 'menu'
|
|
|
+ });
|
|
|
+
|
|
|
+ if ($(getOptions().menu)[0] && (getOptions().lockAnchors || !getOptions().anchors.length)) {
|
|
|
+ preventDefault(e);
|
|
|
+ /*jshint validthis:true */
|
|
|
+
|
|
|
+ EventEmitter.emit(events.onMenuClick, {
|
|
|
+ anchor: getAttr(this, 'data-menuanchor')
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ EventEmitter.on(events.bindEvents, bindEvents$2);
|
|
|
+
|
|
|
+ function bindEvents$2() {
|
|
|
+ EventEmitter.on(events.onClickOrTouch, onClickOrTouch);
|
|
|
+ }
|
|
|
+
|
|
|
+ function onClickOrTouch(params) {
|
|
|
+ var target = params.target;
|
|
|
+
|
|
|
+ if (target && closest(target, SECTION_NAV_SEL + ' a')) {
|
|
|
+ sectionBulletHandler.call(target, params.e);
|
|
|
+ } else if (matches(target, SECTION_NAV_TOOLTIP_SEL)) {
|
|
|
+ tooltipTextHandler.call(target);
|
|
|
+ } else if (matches(target, SLIDES_NAV_LINK_SEL) || closest(target, SLIDES_NAV_LINK_SEL) != null) {
|
|
|
+ slideBulletHandler.call(target, params.e);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var lastScroll = 0;
|
|
|
+ var g_scrollId;
|
|
|
+ var g_scrollId2;
|
|
|
+ EventEmitter.on(events.onDestroy, onDestroy$1); //when scrolling...
|
|
|
+
|
|
|
+ function scrollHandler(e) {
|
|
|
+ var currentSection;
|
|
|
+ var currentSectionElem;
|
|
|
+
|
|
|
+ if (state.isResizing || !getState().activeSection) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ getLast(getState().sections);
|
|
|
+
|
|
|
+ if (getState().isBeyondFullpage || getState().isAboutToScrollToFullPage) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!getOptions().autoScrolling || getOptions().scrollBar) {
|
|
|
+ var currentScroll = getScrollTop();
|
|
|
+ var scrollDirection = getScrollDirection(currentScroll);
|
|
|
+ var visibleSectionIndex = 0;
|
|
|
+ var screen_mid = currentScroll + getWindowHeight() / 2.0;
|
|
|
+ var isAtBottom = $body.scrollHeight - getWindowHeight() === currentScroll;
|
|
|
+ var sections = getState().sections;
|
|
|
+ setState({
|
|
|
+ scrollY: currentScroll
|
|
|
+ }); //when using `auto-height` for a small last section it won't be centered in the viewport
|
|
|
+
|
|
|
+ if (isAtBottom) {
|
|
|
+ visibleSectionIndex = sections.length - 1;
|
|
|
+ } //is at top? when using `auto-height` for a small first section it won't be centered in the viewport
|
|
|
+ else if (!currentScroll) {
|
|
|
+ visibleSectionIndex = 0;
|
|
|
+ } //taking the section which is showing more content in the viewport
|
|
|
+ else {
|
|
|
+ for (var i = 0; i < sections.length; ++i) {
|
|
|
+ var section = sections[i].item; // Pick the the last section which passes the middle line of the screen.
|
|
|
+
|
|
|
+ if (section.offsetTop <= screen_mid) {
|
|
|
+ visibleSectionIndex = i;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (isCompletelyInViewPort(scrollDirection)) {
|
|
|
+ if (!hasClass(getState().activeSection.item, COMPLETELY)) {
|
|
|
+ addClass(getState().activeSection.item, COMPLETELY);
|
|
|
+ removeClass(siblings(getState().activeSection.item), COMPLETELY);
|
|
|
+ }
|
|
|
+ } //geting the last one, the current one on the screen
|
|
|
+
|
|
|
+
|
|
|
+ currentSection = sections[visibleSectionIndex];
|
|
|
+ currentSectionElem = currentSection.item; //setting the visible section as active when manually scrolling
|
|
|
+ //executing only once the first time we reach the section
|
|
|
+
|
|
|
+ if (!currentSection.isActive) {
|
|
|
+ setState({
|
|
|
+ isScrolling: true
|
|
|
+ });
|
|
|
+ var leavingSection = getState().activeSection.item;
|
|
|
+ var leavingSectionIndex = getState().activeSection.index() + 1;
|
|
|
+ var yMovement = getYmovement(getState().activeSection, currentSectionElem);
|
|
|
+ var anchorLink = currentSection.anchor;
|
|
|
+ var sectionIndex = currentSection.index() + 1;
|
|
|
+ var activeSlide = currentSection.activeSlide;
|
|
|
+ var slideIndex;
|
|
|
+ var slideAnchorLink;
|
|
|
+ var callbacksParams = {
|
|
|
+ activeSection: leavingSection,
|
|
|
+ sectionIndex: sectionIndex - 1,
|
|
|
+ anchorLink: anchorLink,
|
|
|
+ element: currentSectionElem,
|
|
|
+ leavingSection: leavingSectionIndex,
|
|
|
+ direction: yMovement,
|
|
|
+ items: {
|
|
|
+ origin: getState().activeSection,
|
|
|
+ destination: currentSection
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ if (activeSlide) {
|
|
|
+ slideAnchorLink = activeSlide.anchor;
|
|
|
+ slideIndex = activeSlide.index();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (state.canScroll) {
|
|
|
+ addClass(currentSectionElem, ACTIVE);
|
|
|
+ removeClass(siblings(currentSectionElem), ACTIVE);
|
|
|
+
|
|
|
+ if (isFunction(getOptions().beforeLeave)) {
|
|
|
+ fireCallbackOncePerScroll('beforeLeave', callbacksParams);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (isFunction(getOptions().onLeave)) {
|
|
|
+ fireCallback('onLeave', callbacksParams);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (isFunction(getOptions().afterLoad)) {
|
|
|
+ fireCallback('afterLoad', callbacksParams);
|
|
|
+ }
|
|
|
+
|
|
|
+ stopMedia(leavingSection);
|
|
|
+ lazyLoad(currentSectionElem);
|
|
|
+ playMedia(currentSectionElem);
|
|
|
+ activateMenuAndNav(anchorLink, sectionIndex - 1);
|
|
|
+
|
|
|
+ if (getOptions().anchors.length) {
|
|
|
+ //needed to enter in hashChange event when using the menu with anchor links
|
|
|
+ setState({
|
|
|
+ lastScrolledDestiny: anchorLink
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ updateState();
|
|
|
+ setPageStatus(slideIndex, slideAnchorLink, anchorLink);
|
|
|
+ } //small timeout in order to avoid entering in hashChange event when scrolling is not finished yet
|
|
|
+
|
|
|
+
|
|
|
+ clearTimeout(g_scrollId);
|
|
|
+ g_scrollId = setTimeout(function () {
|
|
|
+ setState({
|
|
|
+ isScrolling: false
|
|
|
+ });
|
|
|
+ }, 100);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (getOptions().fitToSection && state.canScroll) {
|
|
|
+ clearTimeout(g_scrollId2);
|
|
|
+ g_scrollId2 = setTimeout(function () {
|
|
|
+ var fixedSections = state.sections.filter(function (section) {
|
|
|
+ var sectionValues = section.item.getBoundingClientRect();
|
|
|
+ return Math.round(sectionValues.bottom) === Math.round(getWindowHeight()) || Math.round(sectionValues.top) === 0;
|
|
|
+ }); // No section is fitting the viewport? Let's fix that!
|
|
|
+
|
|
|
+ if (!fixedSections.length) {
|
|
|
+ fitToSection();
|
|
|
+ }
|
|
|
+ }, getOptions().fitToSectionDelay);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ function onDestroy$1() {
|
|
|
+ clearTimeout(g_scrollId);
|
|
|
+ clearTimeout(g_scrollId2);
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets the directon of the the scrolling fired by the scroll event.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function getScrollDirection(currentScroll) {
|
|
|
+ var direction = currentScroll > lastScroll ? 'down' : 'up';
|
|
|
+ lastScroll = currentScroll; //needed for auto-height sections to determine if we want to scroll to the top or bottom of the destination
|
|
|
+
|
|
|
+ setState({
|
|
|
+ previousDestTop: currentScroll
|
|
|
+ });
|
|
|
+ return direction;
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Determines whether the active section has seen in its whole or not.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function isCompletelyInViewPort(movement) {
|
|
|
+ var top = getState().activeSection.item.offsetTop;
|
|
|
+ var bottom = top + getWindowHeight();
|
|
|
+
|
|
|
+ if (movement == 'up') {
|
|
|
+ return bottom >= getScrollTop() + getWindowHeight();
|
|
|
+ }
|
|
|
+
|
|
|
+ return top <= getScrollTop();
|
|
|
+ }
|
|
|
+
|
|
|
+ EventEmitter.on(events.bindEvents, bindEvents$1);
|
|
|
+ EventEmitter.on(events.onDestroy, onDestroy);
|
|
|
+
|
|
|
+ function onDestroy() {
|
|
|
+ windowRemoveEvent('scroll', scrollHandler);
|
|
|
+ }
|
|
|
+
|
|
|
+ function bindEvents$1() {
|
|
|
+ windowAddEvent('scroll', scrollHandler);
|
|
|
+ doc.body.addEventListener('scroll', scrollHandler);
|
|
|
+ EventEmitter.on(events.onScrollPageAndSlide, function (params) {
|
|
|
+ scrollPageAndSlide(params.sectionAnchor, params.slideAnchor);
|
|
|
+ });
|
|
|
+ EventEmitter.on(events.onMenuClick, function (params) {
|
|
|
+ moveTo$1(params.anchor, undefined);
|
|
|
+ });
|
|
|
+ EventEmitter.on(events.onScrollOverflowScrolled, function (params) {
|
|
|
+ var scrollSection = params.direction === 'down' ? moveSectionDown : moveSectionUp;
|
|
|
+ scrollSection();
|
|
|
+ });
|
|
|
+ EventEmitter.on(events.scrollPage, function (params) {
|
|
|
+ scrollPage(params.destination);
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ FP.getActiveSlide = getActiveSlide;
|
|
|
+
|
|
|
+ FP.getScrollX = function () {
|
|
|
+ return state.scrollX;
|
|
|
+ };
|
|
|
+
|
|
|
+ EventEmitter.on(events.bindEvents, bindEvents);
|
|
|
+
|
|
|
+ function bindEvents() {
|
|
|
+ EventEmitter.on(events.onDestroy, onDestroy$6);
|
|
|
+ EventEmitter.on(events.landscapeScroll, function (params) {
|
|
|
+ landscapeScroll(params.slides, params.destination);
|
|
|
+ });
|
|
|
+ EventEmitter.on(events.moveSlideRight, function (params) {
|
|
|
+ moveSlideRight(params.section);
|
|
|
+ });
|
|
|
+ EventEmitter.on(events.moveSlideLeft, function (params) {
|
|
|
+ moveSlideLeft(params.section);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Gets the active slide.
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function getActiveSlide() {
|
|
|
+ return nullOrSlide(getState().activeSection.activeSlide);
|
|
|
+ }
|
|
|
+
|
|
|
+ EventEmitter.on(events.bindEvents, init$1);
|
|
|
+
|
|
|
+ function init$1() {
|
|
|
+ var position = getOptions().credits.position || 'right';
|
|
|
+ var positionStyle = ['left', 'right'].indexOf(position) > -1 ? "".concat(position, ": 0;") : '';
|
|
|
+ var waterMark = "\n <div class=\"fp-watermark\" style=\"".concat(positionStyle, "\">\n <a href=\"https://alvarotrigo.com/fullPage/\" \n rel=\"nofollow noopener\" \n target=\"_blank\" \n style=\"text-decoration:none; color: #000;\">\n ").concat(getOptions().credits.label || 'Made with fullPage.js', "\n </a>\n </div>\n ");
|
|
|
+ var lastSection = getLast(state.sections);
|
|
|
+ var shouldUseWaterMark = !state.isValid || getOptions().credits.enabled;
|
|
|
+
|
|
|
+ if (lastSection && lastSection.item && shouldUseWaterMark) {
|
|
|
+ lastSection.item.insertAdjacentHTML('beforeend', waterMark);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ !function () {
|
|
|
+ EventEmitter.on(events.onInitialise, function () {
|
|
|
+ var n, a, l;
|
|
|
+ setState({
|
|
|
+ isValid: (getOptions().licenseKey, n = getOptions().licenseKey, a = function (n) {
|
|
|
+ var e = parseInt("\x35\x31\x34").toString(16);
|
|
|
+ if (!n || n.length < 29 || 4 === n.split(t[0]).length) return null;
|
|
|
+ var r = ["\x45\x61\x63\x68", "\x66\x6f\x72"][i()]().join(""),
|
|
|
+ a = n[["\x73\x70\x6c\x69\x74"]]("-"),
|
|
|
+ l = [];
|
|
|
+ a[r](function (t, n) {
|
|
|
+ if (n < 4) {
|
|
|
+ var r = function (t) {
|
|
|
+ var n = t[t.length - 1],
|
|
|
+ e = ["\x4e\x61\x4e", "\x69\x73"][i()]().join("");
|
|
|
+ return window[e](n) ? o(n) : function (t) {
|
|
|
+ return t - ACTIVE.length;
|
|
|
+ }(n);
|
|
|
+ }(t);
|
|
|
+
|
|
|
+ l.push(r);
|
|
|
+ var s = o(t[r]);
|
|
|
+
|
|
|
+ if (1 === n) {
|
|
|
+ var a = ["\x70\x61", "\x64\x53", "\x74", "\x61\x72\x74"].join("");
|
|
|
+ s = s.toString()[a](2, "0");
|
|
|
+ }
|
|
|
+
|
|
|
+ e += s, 0 !== n && 1 !== n || (e += "-");
|
|
|
+ }
|
|
|
+ });
|
|
|
+ var m = 0,
|
|
|
+ f = "";
|
|
|
+ return n.split("-").forEach(function (t, n) {
|
|
|
+ if (n < 4) {
|
|
|
+ var _i = 0;
|
|
|
+
|
|
|
+ for (var e = 0; e < 4; e++) {
|
|
|
+ e !== l[n] && (_i += Math.abs(o(t[e])), isNaN(t[e]) || m++);
|
|
|
+ }
|
|
|
+
|
|
|
+ var r = s(_i);
|
|
|
+ f += r;
|
|
|
+ }
|
|
|
+ }), f += s(m), {
|
|
|
+ v: new Date(e + "T00:00"),
|
|
|
+ o: e.split("-")[2] === 8 * (ACTIVE.length - 2) + "",
|
|
|
+ l: f
|
|
|
+ };
|
|
|
+ }(n), l = function (t) {
|
|
|
+ var n = r[i()]().join("");
|
|
|
+ return t && 0 === n.indexOf(t) && t.length === n.length;
|
|
|
+ }(n), (a || l) && (a && e <= a.v && a.l === n.split(t[0])[4] || l || a.o) || !1)
|
|
|
+ });
|
|
|
+ });
|
|
|
+ var t = ["-"];
|
|
|
+ var n = "\x32\x30\x32\x33\x2d\x34\x2d\x32\x39".split("-"),
|
|
|
+ e = new Date(n[0], n[1], n[2]),
|
|
|
+ r = ["se", "licen", "-", "v3", "l", "gp"];
|
|
|
+
|
|
|
+ function i() {
|
|
|
+ return [["\x72\x65", "\x76\x65\x72\x73\x65"].join("")]["".length];
|
|
|
+ }
|
|
|
+
|
|
|
+ function o(t) {
|
|
|
+ return t ? isNaN(t) ? t.charCodeAt(0) - 72 : t : "";
|
|
|
+ }
|
|
|
+
|
|
|
+ function s(t) {
|
|
|
+ var n = 72 + t;
|
|
|
+ return n > 90 && n < 97 && (n += 15), String.fromCharCode(n).toUpperCase();
|
|
|
+ }
|
|
|
+ }();
|
|
|
+
|
|
|
+ //@ts-check
|
|
|
+ FP.setKeyboardScrolling = setKeyboardScrolling;
|
|
|
+ /**
|
|
|
+ * Adds or remove the possibility of scrolling through sections by using the keyboard arrow keys
|
|
|
+ */
|
|
|
+
|
|
|
+ function setKeyboardScrolling(value, directions) {
|
|
|
+ if (typeof directions !== 'undefined') {
|
|
|
+ directions = directions.replace(/ /g, '').split(',');
|
|
|
+ directions.forEach(function (direction) {
|
|
|
+ setIsScrollAllowed(value, direction, 'k');
|
|
|
+ });
|
|
|
+ } else {
|
|
|
+ setIsScrollAllowed(value, 'all', 'k');
|
|
|
+ getOptions().keyboardScrolling = value;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Sets the data-anchor attributes to the menu elements and activates the current one.
|
|
|
+ */
|
|
|
+
|
|
|
+ function styleMenu(section) {
|
|
|
+ var index = section.index();
|
|
|
+
|
|
|
+ if (typeof getOptions().anchors[index] !== 'undefined') {
|
|
|
+ //activating the menu / nav element on load
|
|
|
+ if (section.isActive) {
|
|
|
+ activateMenuAndNav(getOptions().anchors[index], index);
|
|
|
+ }
|
|
|
+ } //moving the menu outside the main container if it is inside (avoid problems with fixed positions when using CSS3 tranforms)
|
|
|
+
|
|
|
+
|
|
|
+ if (getOptions().menu && getOptions().css3 && closest($(getOptions().menu)[0], WRAPPER_SEL) != null) {
|
|
|
+ $(getOptions().menu).forEach(function (menu) {
|
|
|
+ $body.appendChild(menu);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Works over the DOM structure to set it up for the current fullpage getOptions().
|
|
|
+ */
|
|
|
+
|
|
|
+ function prepareDom() {
|
|
|
+ css(getParentsUntil(getContainer(), 'body'), {
|
|
|
+ 'height': '100%',
|
|
|
+ 'position': 'relative'
|
|
|
+ }); //adding a class to recognize the container internally in the code
|
|
|
+
|
|
|
+ addClass(getContainer(), WRAPPER);
|
|
|
+ addClass($html, ENABLED); //due to https://github.com/alvarotrigo/fullPage.js/issues/1502
|
|
|
+
|
|
|
+ setState({
|
|
|
+ windowsHeight: getWindowHeight()
|
|
|
+ });
|
|
|
+ removeClass(getContainer(), DESTROYED); //in case it was destroyed before initializing it again
|
|
|
+
|
|
|
+ addInternalSelectors();
|
|
|
+ var sections = getState().sectionsIncludingHidden; //styling the sections / slides / menu
|
|
|
+
|
|
|
+ for (var i = 0; i < sections.length; i++) {
|
|
|
+ var section = sections[i];
|
|
|
+ var slides = section.allSlidesItems; //caching the original styles to add them back on destroy('all')
|
|
|
+
|
|
|
+ var originalStyles = getAttr(section.item, 'style');
|
|
|
+
|
|
|
+ if (originalStyles) {
|
|
|
+ section.item.setAttribute('data-fp-styles', originalStyles);
|
|
|
+ }
|
|
|
+
|
|
|
+ styleSection(section);
|
|
|
+ styleMenu(section); // if there's any slide
|
|
|
+
|
|
|
+ if (slides.length > 0) {
|
|
|
+ styleSlides(section);
|
|
|
+ }
|
|
|
+ } //fixed elements need to be moved out of the plugin container due to problems with CSS3.
|
|
|
+
|
|
|
+
|
|
|
+ if (getOptions().fixedElements && getOptions().css3) {
|
|
|
+ $(getOptions().fixedElements).forEach(function (item) {
|
|
|
+ $body.appendChild(item);
|
|
|
+ });
|
|
|
+ } //vertical centered of the navigation + active bullet
|
|
|
+
|
|
|
+
|
|
|
+ if (getOptions().navigation) {
|
|
|
+ addVerticalNavigation();
|
|
|
+ }
|
|
|
+
|
|
|
+ enableYoutubeAPI();
|
|
|
+
|
|
|
+ if (getOptions().scrollOverflow) {
|
|
|
+ scrollOverflowHandler.makeScrollable();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ FP.shared.afterRenderActions = afterRenderActions;
|
|
|
+ /**
|
|
|
+ * Actions and callbacks to fire afterRender
|
|
|
+ */
|
|
|
+
|
|
|
+ function afterRenderActions() {
|
|
|
+ var section = getState().activeSection;
|
|
|
+ var sectionElem = getState().activeSection.item;
|
|
|
+ addClass(sectionElem, COMPLETELY);
|
|
|
+ lazyLoad(sectionElem);
|
|
|
+ lazyLoadOthers();
|
|
|
+ playMedia(sectionElem);
|
|
|
+
|
|
|
+ if (isDestinyTheStartingSection() && isFunction(getOptions().afterLoad)) {
|
|
|
+ fireCallback('afterLoad', {
|
|
|
+ activeSection: sectionElem,
|
|
|
+ element: sectionElem,
|
|
|
+ direction: null,
|
|
|
+ //for backwards compatibility callback (to be removed in a future!)
|
|
|
+ anchorLink: section.anchor,
|
|
|
+ sectionIndex: section.index(),
|
|
|
+ items: {
|
|
|
+ origin: getState().activeSection,
|
|
|
+ destination: getState().activeSection
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ if (isFunction(getOptions().afterRender)) {
|
|
|
+ fireCallback('afterRender');
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /**
|
|
|
+ * Determines if the URL anchor destiny is the starting section (the one using 'active' class before initialization)
|
|
|
+ */
|
|
|
+
|
|
|
+ function isDestinyTheStartingSection() {
|
|
|
+ var anchor = getAnchorsURL();
|
|
|
+ var destinationSection = getSectionByAnchor(anchor.section);
|
|
|
+ return !anchor.section || !destinationSection || typeof destinationSection !== 'undefined' && destinationSection.index() === index(getStartingSection());
|
|
|
+ }
|
|
|
+
|
|
|
+ FP.setAllowScrolling = setAllowScrolling;
|
|
|
+ /**
|
|
|
+ * Adds or remove the possibility of scrolling through sections by using the mouse wheel/trackpad or touch gestures.
|
|
|
+ * Optionally a second parameter can be used to specify the direction for which the action will be applied.
|
|
|
+ *
|
|
|
+ * @param directions string containing the direction or directions separated by comma.
|
|
|
+ */
|
|
|
+
|
|
|
+ function setAllowScrolling(value, directions) {
|
|
|
+ if (typeof directions !== 'undefined') {
|
|
|
+ directions = directions.replace(/ /g, '').split(',');
|
|
|
+ directions.forEach(function (direction) {
|
|
|
+ setIsScrollAllowed(value, direction, 'm');
|
|
|
+ });
|
|
|
+ } else {
|
|
|
+ setIsScrollAllowed(value, 'all', 'm');
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * Scrolls to the anchor in the URL when loading the site
|
|
|
+ */
|
|
|
+
|
|
|
+ function scrollToAnchor() {
|
|
|
+ var anchors = getAnchorsURL();
|
|
|
+ var sectionAnchor = anchors.section;
|
|
|
+ var slideAnchor = anchors.slide;
|
|
|
+
|
|
|
+ if (sectionAnchor) {
|
|
|
+ //if theres any #
|
|
|
+ if (getOptions().animateAnchor) {
|
|
|
+ scrollPageAndSlide(sectionAnchor, slideAnchor);
|
|
|
+ } else {
|
|
|
+ silentMoveTo(sectionAnchor, slideAnchor);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ EventEmitter.emit(events.onAfterRenderNoAnchor, null);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /*
|
|
|
+ * Removes inline styles added by fullpage.js
|
|
|
+ */
|
|
|
+
|
|
|
+ function destroyStructure() {
|
|
|
+ //reseting the `top` or `translate` properties to 0
|
|
|
+ silentScroll(0); //loading all the lazy load content
|
|
|
+
|
|
|
+ $('img[data-src], source[data-src], audio[data-src], iframe[data-src]', getContainer()).forEach(function (item) {
|
|
|
+ setSrc(item, 'src');
|
|
|
+ });
|
|
|
+ $('img[data-srcset]').forEach(function (item) {
|
|
|
+ setSrc(item, 'srcset');
|
|
|
+ });
|
|
|
+ remove($(SECTION_NAV_SEL + ', ' + SLIDES_NAV_SEL + ', ' + SLIDES_ARROW_SEL)); //removing inline styles
|
|
|
+
|
|
|
+ css(getNodes(getState().sections), {
|
|
|
+ 'height': '',
|
|
|
+ 'background-color': '',
|
|
|
+ 'padding': ''
|
|
|
+ });
|
|
|
+ css(getNodes(getState().slides), {
|
|
|
+ 'width': ''
|
|
|
+ });
|
|
|
+ css(getContainer(), {
|
|
|
+ 'height': '',
|
|
|
+ 'position': '',
|
|
|
+ '-ms-touch-action': '',
|
|
|
+ 'touch-action': ''
|
|
|
+ });
|
|
|
+ css($htmlBody, {
|
|
|
+ 'overflow': '',
|
|
|
+ 'height': ''
|
|
|
+ }); // remove .fp-enabled class
|
|
|
+
|
|
|
+ removeClass($html, ENABLED); // remove .fp-responsive class & .fp-scrollable
|
|
|
+
|
|
|
+ removeClass($body, RESPONSIVE + ' ' + SCROLLABLE); // remove all of the .fp-viewing- classes
|
|
|
+
|
|
|
+ $body.className.split(/\s+/).forEach(function (className) {
|
|
|
+ if (className.indexOf(VIEWING_PREFIX) === 0) {
|
|
|
+ removeClass($body, className);
|
|
|
+ }
|
|
|
+ }); //removing added classes
|
|
|
+
|
|
|
+ getNodes(getState().panels).forEach(function (item) {
|
|
|
+ if (getOptions().scrollOverflow) {
|
|
|
+ scrollOverflowHandler.destroyWrapper(item);
|
|
|
+ }
|
|
|
+
|
|
|
+ removeClass(item, TABLE + ' ' + ACTIVE + ' ' + COMPLETELY + ' ' + IS_OVERFLOW);
|
|
|
+ var previousStyles = getAttr(item, 'data-fp-styles');
|
|
|
+
|
|
|
+ if (previousStyles) {
|
|
|
+ item.setAttribute('style', previousStyles);
|
|
|
+ } //removing anchors if they were not set using the HTML markup
|
|
|
+
|
|
|
+
|
|
|
+ if (hasClass(item, SECTION) && !getInitialAnchorsInDom()) {
|
|
|
+ item.removeAttribute('data-anchor');
|
|
|
+ }
|
|
|
+ }); //removing the applied transition from the fullpage wrapper
|
|
|
+
|
|
|
+ removeAnimation(getContainer()); //Unwrapping content
|
|
|
+
|
|
|
+ [TABLE_CELL_SEL, SLIDES_CONTAINER_SEL, SLIDES_WRAPPER_SEL].forEach(function (selector) {
|
|
|
+ $(selector, getContainer()).forEach(function (item) {
|
|
|
+ //unwrap not being use in case there's no child element inside and its just text
|
|
|
+ unwrap(item);
|
|
|
+ });
|
|
|
+ }); //removing the applied transition from the fullpage wrapper
|
|
|
+
|
|
|
+ css(getContainer(), {
|
|
|
+ '-webkit-transition': 'none',
|
|
|
+ 'transition': 'none'
|
|
|
+ });
|
|
|
+ removeClass(getContainer(), WRAPPER); //scrolling the page to the top with no animation
|
|
|
+
|
|
|
+ win.scrollTo(0, 0); //removing selectors
|
|
|
+
|
|
|
+ var usedSelectors = [SECTION, SLIDE, SLIDES_CONTAINER];
|
|
|
+ usedSelectors.forEach(function (item) {
|
|
|
+ removeClass($('.' + item), item);
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ FP.destroy = destroy;
|
|
|
+ function init() {
|
|
|
+ updateStructuralState();
|
|
|
+ updateState();
|
|
|
+ getOptions().scrollBar = getOptions().scrollBar || getOptions().hybrid;
|
|
|
+ setOptionsFromDOM();
|
|
|
+ prepareDom();
|
|
|
+ setAllowScrolling(true);
|
|
|
+ setMouseHijack(true);
|
|
|
+ setAutoScrolling(getOptions().autoScrolling, 'internal');
|
|
|
+ responsive(); //setting the class for the body element
|
|
|
+
|
|
|
+ setBodyClass();
|
|
|
+
|
|
|
+ if (doc.readyState === 'complete') {
|
|
|
+ scrollToAnchor();
|
|
|
+ }
|
|
|
+
|
|
|
+ windowAddEvent('load', scrollToAnchor);
|
|
|
+ afterRenderActions(); // Updating the state again with the new DOM
|
|
|
+
|
|
|
+ updateStructuralState();
|
|
|
+ updateState();
|
|
|
+ }
|
|
|
+ /*
|
|
|
+ * Destroys fullpage.js plugin events and optinally its html markup and styles
|
|
|
+ */
|
|
|
+
|
|
|
+ function destroy(all) {
|
|
|
+ setAutoScrolling(false, 'internal');
|
|
|
+ setAllowScrolling(true);
|
|
|
+ setMouseHijack(false);
|
|
|
+ setKeyboardScrolling(false);
|
|
|
+ addClass(getContainer(), DESTROYED);
|
|
|
+ EventEmitter.emit(events.onDestroy); //lets make a mess!
|
|
|
+
|
|
|
+ if (all) {
|
|
|
+ destroyStructure();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ var isOK = function isOK() {
|
|
|
+ return getOptions() && state.isValid || doc.domain.indexOf('al' + 'varotri' + 'go' + '.' + 'com') > -1;
|
|
|
+ };
|
|
|
+ /**
|
|
|
+ * Displays warnings
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+ function displayWarnings() {
|
|
|
+ var l = getOptions()['li' + 'c' + 'enseK' + 'e' + 'y'];
|
|
|
+ var msgStyle = 'font-size: 15px;background:yellow;';
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ if (hasClass($html, ENABLED)) {
|
|
|
+ showError('error', 'Fullpage.js can only be initialized once and you are doing it multiple times!');
|
|
|
+ return;
|
|
|
+ } // Disable mutually exclusive settings
|
|
|
+
|
|
|
+
|
|
|
+ if (getOptions().continuousVertical && (getOptions().loopTop || getOptions().loopBottom)) {
|
|
|
+ getOptions().continuousVertical = false;
|
|
|
+ showError('warn', 'Option `loopTop/loopBottom` is mutually exclusive with `continuousVertical`; `continuousVertical` disabled');
|
|
|
+ }
|
|
|
+
|
|
|
+ if (getOptions().scrollOverflow && (getOptions().scrollBar || !getOptions().autoScrolling)) {
|
|
|
+ showError('warn', 'Options scrollBar:true and autoScrolling:false are mutually exclusive with scrollOverflow:true. Sections with scrollOverflow might not work well in Firefox');
|
|
|
+ }
|
|
|
+
|
|
|
+ if (getOptions().continuousVertical && (getOptions().scrollBar || !getOptions().autoScrolling)) {
|
|
|
+ getOptions().continuousVertical = false;
|
|
|
+ showError('warn', 'Scroll bars (`scrollBar:true` or `autoScrolling:false`) are mutually exclusive with `continuousVertical`; `continuousVertical` disabled');
|
|
|
+ } //using extensions? Wrong file!
|
|
|
+
|
|
|
+
|
|
|
+ extensions.forEach(function (extension) {
|
|
|
+ //is the option set to true?
|
|
|
+ if (getOptions()[extension]) {
|
|
|
+ showError('warn', 'fullpage.js extensions require fullpage.extensions.min.js file instead of the usual fullpage.js. Requested: ' + extension);
|
|
|
+ }
|
|
|
+ }); //anchors can not have the same value as any element ID or NAME
|
|
|
+
|
|
|
+ getOptions().anchors.forEach(function (name) {
|
|
|
+ //case insensitive selectors (http://stackoverflow.com/a/19465187/1081396)
|
|
|
+ var nameAttr = [].slice.call($('[name]')).filter(function (item) {
|
|
|
+ return getAttr(item, 'name') && getAttr(item, 'name').toLowerCase() == name.toLowerCase();
|
|
|
+ });
|
|
|
+ var idAttr = [].slice.call($('[id]')).filter(function (item) {
|
|
|
+ return getAttr(item, 'id') && getAttr(item, 'id').toLowerCase() == name.toLowerCase();
|
|
|
+ });
|
|
|
+
|
|
|
+ if (idAttr.length || nameAttr.length) {
|
|
|
+ showError('error', 'data-anchor tags can not have the same value as any `id` element on the site (or `name` element for IE).');
|
|
|
+ var propertyName = idAttr.length ? 'id' : 'name';
|
|
|
+
|
|
|
+ if (idAttr.length || nameAttr.length) {
|
|
|
+ showError('error', '"' + name + '" is is being used by another element `' + propertyName + '` property');
|
|
|
+ }
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+
|
|
|
+ function fullpage(containerSelector, options) {
|
|
|
+ setCache(); //only once my friend!
|
|
|
+
|
|
|
+ if (hasClass($html, ENABLED)) {
|
|
|
+ displayWarnings();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ setOption('touchWrapper', typeof containerSelector === 'string' ? $(containerSelector)[0] : containerSelector); // Creating some defaults, extending them with any options that were provided
|
|
|
+
|
|
|
+ setOptions(options);
|
|
|
+ setContainer(typeof containerSelector === 'string' ? $(containerSelector)[0] : containerSelector);
|
|
|
+ EventEmitter.emit(events.onInitialise);
|
|
|
+ displayWarnings();
|
|
|
+ setAPI();
|
|
|
+
|
|
|
+ if (getContainer()) {
|
|
|
+ EventEmitter.emit(events.beforeInit);
|
|
|
+ init();
|
|
|
+ EventEmitter.emit(events.bindEvents);
|
|
|
+ } // @ts-ignore
|
|
|
+
|
|
|
+
|
|
|
+ return win.fullpage_api;
|
|
|
+ }
|
|
|
+
|
|
|
+ function setAPI() {
|
|
|
+ FP.getFullpageData = function () {
|
|
|
+ return {
|
|
|
+ options: getOptions()
|
|
|
+ };
|
|
|
+ }; //public functions
|
|
|
+
|
|
|
+
|
|
|
+ FP.version = '4.0.20';
|
|
|
+ FP.test = Object.assign(FP.test, {
|
|
|
+ top: '0px',
|
|
|
+ translate3d: 'translate3d(0px, 0px, 0px)',
|
|
|
+ translate3dH: function () {
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for (var i = 0; i < $(getOptions().sectionSelector, getContainer()).length; i++) {
|
|
|
+ a.push('translate3d(0px, 0px, 0px)');
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+ }(),
|
|
|
+ left: function () {
|
|
|
+ var a = [];
|
|
|
+
|
|
|
+ for (var i = 0; i < $(getOptions().sectionSelector, getContainer()).length; i++) {
|
|
|
+ a.push(0);
|
|
|
+ }
|
|
|
+
|
|
|
+ return a;
|
|
|
+ }(),
|
|
|
+ options: getOptions(),
|
|
|
+ setAutoScrolling: null
|
|
|
+ }); //functions we want to share across files but which are not
|
|
|
+ //mean to be used on their own by developers
|
|
|
+
|
|
|
+ FP.shared = Object.assign(FP.shared, {
|
|
|
+ afterRenderActions: null,
|
|
|
+ isNormalScrollElement: false
|
|
|
+ }); // @ts-ignore
|
|
|
+
|
|
|
+ win.fullpage_api = FP;
|
|
|
+ }
|
|
|
+
|
|
|
+ // @ts-ignore
|
|
|
+
|
|
|
+ win.fp_easings = deepExtend(win.fp_easings, {
|
|
|
+ easeInOutCubic: function easeInOutCubic(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;
|
|
|
+ }
|
|
|
+ });
|
|
|
+
|
|
|
+ /**
|
|
|
+ * jQuery adapter for fullPage.js 3.0.0
|
|
|
+ */
|
|
|
+ // @ts-ignore
|
|
|
+
|
|
|
+ if (win.jQuery) {
|
|
|
+ (function ($, fullpage) {
|
|
|
+
|
|
|
+ if (!$ || !fullpage) {
|
|
|
+ showError('error', 'jQuery is required to use the jQuery fullpage adapter!');
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ $.fn.fullpage = function (options) {
|
|
|
+ options = $.extend({}, options, {
|
|
|
+ '$': $
|
|
|
+ });
|
|
|
+ new fullpage(this[0], options); // Creating the $.fn.fullpage object
|
|
|
+
|
|
|
+ Object.keys(FP).forEach(function (key) {
|
|
|
+ getOptions().$.fn.fullpage[key] = FP[key];
|
|
|
+ });
|
|
|
+ }; // @ts-ignore
|
|
|
+
|
|
|
+ })(win.jQuery, fullpage);
|
|
|
+ }
|
|
|
+
|
|
|
+ return fullpage;
|
|
|
+
|
|
|
+}));
|
