3697 lines
108 KiB
JavaScript
3697 lines
108 KiB
JavaScript
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
// console.log("example test wepps!!s");
|
|
|
|
var linotype = require('../../../index');
|
|
|
|
window.onload =function(){
|
|
window.Linotype = new linotype({
|
|
verticalCentered: false
|
|
});
|
|
window.Linotype.init();
|
|
};
|
|
},{"../../../index":2}],2:[function(require,module,exports){
|
|
/*
|
|
* linotype
|
|
* http://github.amexpub.com/modules/linotype
|
|
*
|
|
* Copyright (c) 2013 AmexPub. All rights reserved.
|
|
*/
|
|
|
|
module.exports = require('./lib/linotype');
|
|
|
|
},{"./lib/linotype":4}],3:[function(require,module,exports){
|
|
/*
|
|
* linotype
|
|
* https://github.com/typesettin/linotype
|
|
* @author yaw joseph etse
|
|
* Copyright (c) 2014 Typesettin. All rights reserved.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var classie = require('classie');
|
|
// extend = require('util-extend'),
|
|
// events = require('events'),
|
|
// util = require('util');
|
|
|
|
/**
|
|
* A module that adds simple dom utility functionality.
|
|
* @author yaw joseph etse
|
|
* @constructor
|
|
*/
|
|
|
|
var domhelper = {
|
|
|
|
/**
|
|
* toggles class across nodelist/elementcollection
|
|
* @param {object} elementCollection - html dom element
|
|
* @param {object} element - html dom element
|
|
* @param {string} name of class!
|
|
* @public
|
|
*/
|
|
removeAllClassAndToggle: function(element,elementCollection,toggleClass){
|
|
//updating the active class
|
|
for(var h =0; h <elementCollection.length; h++){
|
|
classie.removeClass(elementCollection[h],toggleClass);
|
|
}
|
|
classie.addClass(element,toggleClass);
|
|
},
|
|
/**
|
|
* removes element from dom
|
|
* @param {object} elementCollection - html dom element
|
|
* @public
|
|
*/
|
|
removeElement: function(element){
|
|
//updating the active class
|
|
element.parentNode.removeChild(element);
|
|
},
|
|
/**
|
|
* converts idnex of node in nodelist
|
|
* @param {object} nodelist - html dom element
|
|
* @param {object} element - html dom element
|
|
* @return {number} index of element in nodelist
|
|
* @method
|
|
*/
|
|
nodeIndexOfNodeList: function(nodelist,element){
|
|
return domhelper.nodelistToArray(nodelist,true).indexOf(element.outerHTML);
|
|
},
|
|
|
|
/**
|
|
* converts nodelists to arrays
|
|
* @param {node} nl - html dom element
|
|
* @return { array} array of html nodes
|
|
* @method
|
|
*/
|
|
nodelistToArray: function(nl,useStrings){
|
|
var arr = [];
|
|
for (var i = 0, ref = arr.length = nl.length; i < ref; i++) {
|
|
arr[i] = (useStrings) ? nl[i].outerHTML : nl[i];
|
|
}
|
|
return arr;
|
|
},
|
|
|
|
/**
|
|
* Returns cloaset DOM element.
|
|
* @param {node} element - html dom element
|
|
* @return {node} - closet node element
|
|
* @method
|
|
*/
|
|
closetElement: function(element){
|
|
if(typeof element.length === 'number'){
|
|
return undefined;
|
|
}
|
|
var matches = domhelper.nodelistToArray(document.querySelectorAll(element.nodeName+'.'+element.className.trim().split(" ").join("."))),
|
|
cleanMatches = [];
|
|
// console.log("matches",matches.length,matches);
|
|
|
|
for (var x =0; x < matches.length; x++){
|
|
// console.log('x',x,'element',element,'matches[x]',matches[x],'isEqualNode',matches[x].isEqualNode(element),'compareDocumentPosition',element.compareDocumentPosition(matches[x]));
|
|
if(element.compareDocumentPosition(matches[x])<4 && !matches[x].isEqualNode(element)){
|
|
cleanMatches.push(matches[x]);
|
|
}
|
|
}
|
|
|
|
function compareNumbers(a, b) {
|
|
return a.compareDocumentPosition( b ) - b.compareDocumentPosition( a );
|
|
}
|
|
// console.log("matches cleaned",cleanMatches.length,cleanMatches);
|
|
// console.log("matches sorted",cleanMatches.sort(compareNumbers));
|
|
return cleanMatches[0];
|
|
},
|
|
|
|
/**
|
|
* Hides DOM elements.
|
|
* @method
|
|
* @param {node} element - html dom element
|
|
*/
|
|
elementHideCss: function(element){
|
|
element.style.display="none";
|
|
},
|
|
|
|
/**
|
|
* Shows DOM elements.
|
|
* @method
|
|
* @param {node} element - html dom element
|
|
*/
|
|
elementShowCss: function(element){
|
|
element.setAttribute('style',element.getAttribute('style').replace("display: none;"));
|
|
},
|
|
|
|
/**
|
|
* Wraps inner elements
|
|
* @method
|
|
* @param {node} element - html dom element
|
|
* @param {node} innerElement - element to wrap html dom element
|
|
*/
|
|
elementContentWrapInner: function(element,innerElement){
|
|
var wrapper = element,
|
|
w = innerElement,
|
|
len = element.childElementCount,
|
|
wrapper_clone = wrapper.cloneNode(true);
|
|
|
|
wrapper.innerHTML='';
|
|
wrapper.appendChild(w);
|
|
var newFirstChild = wrapper.firstChild;
|
|
|
|
newFirstChild.innerHTML=wrapper_clone.innerHTML;
|
|
},
|
|
|
|
/**
|
|
* Wraps element with wrapper
|
|
* @method
|
|
* @param {node} element - html dom element
|
|
* @param {node} wrapperElement - element to wrap html dom element
|
|
*/
|
|
elementWrap: function(element,wrapperElement){
|
|
var elementParent =element.parentNode,
|
|
element_clone = element.cloneNode(true);
|
|
|
|
elementParent.replaceChild(wrapperElement,element);
|
|
wrapperElement.appendChild(element);
|
|
},
|
|
|
|
|
|
/**
|
|
* get scroll position of element
|
|
* @method
|
|
* @param {node} element - html dom element
|
|
* @return {number} position of scroll
|
|
*/
|
|
getScrollTop: function(element){
|
|
// console.log(typeof element);
|
|
if(element === window && typeof window.pageYOffset!== 'undefined'){
|
|
//most browsers except IE before #9
|
|
return window.pageYOffset;
|
|
}
|
|
else if(typeof element ==="object"){
|
|
return element.scrollTop;
|
|
}
|
|
else {
|
|
var B= document.body; //IE 'quirks'
|
|
var D= document.documentElement; //IE with doctype
|
|
D= (D.clientHeight)? D: B;
|
|
return D.scrollTop;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* get scroll position of element
|
|
* @method
|
|
* @param {node} element - html dom element
|
|
* @return {object} position element
|
|
*/
|
|
getPosition: function(element) {
|
|
var xPosition = 0;
|
|
var yPosition = 0;
|
|
|
|
while(element) {
|
|
xPosition += (element.offsetLeft - element.scrollLeft + element.clientLeft);
|
|
yPosition += (element.offsetTop - element.scrollTop + element.clientTop);
|
|
element = element.offsetParent;
|
|
}
|
|
return { x: xPosition, y: yPosition, left: xPosition, top: yPosition };
|
|
},
|
|
|
|
/**
|
|
* get element selector
|
|
* @method
|
|
* @param {node} element - html dom element
|
|
* @return {string} query selector string
|
|
*/
|
|
getElementSelector: function(element){
|
|
var tagSelector = (element.tagName) ? element.tagName:'',
|
|
idSelector = (element.id) ? '#'+element.id+'':'',
|
|
classSelector='';
|
|
if(element.classList){
|
|
for(var x=0; x < element.classList.length; x++){
|
|
classSelector+='.'+element.classList[x]+"";
|
|
}
|
|
}
|
|
return tagSelector+idSelector+classSelector;
|
|
},
|
|
|
|
/**
|
|
* get parent element
|
|
* @method
|
|
* @param {node} element - html dom element
|
|
* @param {string} selector - selector
|
|
* @param {string} selectorType - selector type (id or class)
|
|
*/
|
|
getParentElement: function(element,selector,selectorType){
|
|
if(element.tagName==='BODY' || element.tagName==='HTML' || selector==='body' || selector==='html' || selector===undefined){
|
|
// console.log('body selected');
|
|
return undefined;
|
|
}
|
|
else if( (selectorType==='id' && element.parentNode.id === selector) || element.parentNode.className.match(new RegExp(selector,'g'))){
|
|
// console.log("parent node");
|
|
return element.parentNode;
|
|
|
|
//new RegExp(pattern,modifiers)
|
|
}
|
|
else {
|
|
// console.log("look up higher");
|
|
return domhelper.getParentElement(element.parentNode,selector,selectorType);
|
|
}
|
|
},
|
|
|
|
getPreviousElements: function(element,returnArray){
|
|
if(element.previousElementSibling){
|
|
returnArray.push(element.previousElementSibling);
|
|
return domhelper.getPreviousElements(element.previousElementSibling,returnArray);
|
|
}
|
|
else{
|
|
return returnArray;
|
|
}
|
|
},
|
|
|
|
|
|
getNextElements: function(element,returnArray){
|
|
if(element.nextElementSibling){
|
|
returnArray.push(element.nextElementSibling);
|
|
return domhelper.getNextElements(element.nextElementSibling,returnArray);
|
|
}
|
|
else{
|
|
return returnArray;
|
|
}
|
|
},
|
|
|
|
insertAllBefore: function(element,elementsToInsert){
|
|
var parentElement = element.parentNode;
|
|
// console.log("parentElement",parentElement,"element",element,"elementsToInsert",elementsToInsert);
|
|
if(elementsToInsert.length){
|
|
for(var x =0; x<elementsToInsert.length; x++){
|
|
// console.log(x,"elementsToInsert[x]",elementsToInsert[x])
|
|
parentElement.insertBefore(elementsToInsert[x],element);
|
|
}
|
|
}
|
|
else{
|
|
parentElement.insertBefore(elementsToInsert,element);
|
|
}
|
|
},
|
|
|
|
insertAllAfter: function(element,elementsToInsert){
|
|
var parentElement = element.parentNode;
|
|
var nextSibling = element.nextSibling;
|
|
// console.log("parentElement",parentElement,"element",element,"elementsToInsert",elementsToInsert);
|
|
if(elementsToInsert.length){
|
|
for(var x =0; x<elementsToInsert.length; x++){
|
|
// console.log(x,"elementsToInsert[x]",elementsToInsert[x])
|
|
// elementsToInsert[x].style.background="green";
|
|
parentElement.insertBefore(elementsToInsert[x],nextSibling);
|
|
}
|
|
}
|
|
else{
|
|
parentElement.insertBefore(elementsToInsert,nextSibling);
|
|
}
|
|
},
|
|
|
|
unwrapElement: function(element){
|
|
var parentNodeElem = element.parentNode;
|
|
if(parentNodeElem.nodeName !== "BODY"){
|
|
var parentParentNodeElem = parentNodeElem.parentNode;
|
|
parentParentNodeElem.innerHTML='';
|
|
parentParentNodeElem.appendChild(element);
|
|
}
|
|
},
|
|
onWindowLoaded: function(callback){
|
|
var readyStateCheckInterval = setInterval(function() {
|
|
if (document.readyState === "complete") {
|
|
callback();
|
|
clearInterval(readyStateCheckInterval);
|
|
}
|
|
}, 10);
|
|
}
|
|
|
|
};
|
|
|
|
module.exports = domhelper;
|
|
|
|
// If there is a window object, that at least has a document property,
|
|
// define linotype
|
|
if ( typeof window === "object" && typeof window.document === "object" ) {
|
|
window.domhelper = domhelper;
|
|
}
|
|
},{"classie":11}],4:[function(require,module,exports){
|
|
/**
|
|
* @title linotype
|
|
* @{@link https://github.com/typesettin/linotype}
|
|
* @author Yaw Joseph Etse
|
|
* @copyright Copyright (c) 2014 Typesettin. All rights reserved.
|
|
* @license MIT
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var classie = require('classie'),
|
|
extend = require('util-extend'),
|
|
events = require('events'),
|
|
domhelper = require('./domhelper'),
|
|
Slimscroll = require('./slimscroll'),
|
|
util = require('util');
|
|
|
|
/**
|
|
* A module that represents a linotype object, a linotyper is a page composition tool.
|
|
* @{@link https://github.com/typesettin/linotype}
|
|
* @author Yaw Joseph Etse
|
|
* @copyright Copyright (c) 2014 Typesettin. All rights reserved.
|
|
* @license MIT
|
|
* @module linotype
|
|
* @requires module:classie
|
|
* @requires module:util-extent
|
|
* @requires module:util
|
|
* @requires module:events
|
|
* @todo need to finish the .closet implementation for @linotype.getTableHeight method
|
|
* @todo need @linotype~checkParentForNormalScrollElement to fix parent.isEqualNode to loop through selector of normalscrollelements called from @linotype~touchMoveHandler
|
|
* @todo fix resizeme text sizing
|
|
* @throws {ConfigurationError} If conflicting scrolling options are set
|
|
*/
|
|
var linotype = function(config_options){
|
|
/** module default configuration */
|
|
var options,
|
|
linotypeElement,
|
|
defaults = {
|
|
'verticalCentered' : true,
|
|
'resize' : true,
|
|
'slidesColor' : [],
|
|
'anchors':[],
|
|
'scrollingSpeed': 700,
|
|
'easing': 'easeInQuart',
|
|
'menu': false,
|
|
'navigation': false,
|
|
'navigationPosition': 'right',
|
|
'navigationColor': '#000',
|
|
'navigationTooltips': [],
|
|
'slidesNavigation': false,
|
|
'slidesNavPosition': 'bottom',
|
|
'controlArrowColor': '#fff',
|
|
'loopBottom': false,
|
|
'loopTop': false,
|
|
'loopHorizontal': true,
|
|
'autoScrolling': true,
|
|
'scrollOverflow': false,
|
|
'css3': true,
|
|
'paddingTop': 0,
|
|
'paddingBottom': 0,
|
|
'fixedElements': null,
|
|
'normalScrollElements': null,
|
|
'keyboardScrolling': true,
|
|
'touchSensitivity': 5,
|
|
'continuousVertical': false,
|
|
'animateAnchor': true,
|
|
'idSelector' : 'fullpage',
|
|
'normalScrollElementTouchThreshold': 5,
|
|
|
|
//events
|
|
'afterLoad': null,
|
|
'onLeave': null,
|
|
'afterRender': null,
|
|
'afterResize': null,
|
|
'afterSlideLoad': null,
|
|
'onSlideLeave': null
|
|
},
|
|
ConfigurationError = function(message){
|
|
this.name = "ConfigurationError";
|
|
this.message = message || "Linotype Configuration Error";
|
|
},
|
|
scrollDelay = (typeof config_options === "object" && typeof config_options.scrollDelay === "number") ? config_options.scrollDelay : 600,
|
|
container,
|
|
slideMoving = false,
|
|
isTablet = navigator.userAgent.match(/(iPhone|iPod|iPad|Android|BlackBerry|Windows Phone)/),
|
|
windowsHeight,
|
|
isMoving = false,
|
|
isResizing = false,
|
|
resizeTimeout = false,
|
|
lastScrolledDestiny,
|
|
lastScrolledSlide,
|
|
scrollId,
|
|
isScrolling = false,
|
|
touchStartY = 0,
|
|
touchStartX = 0,
|
|
touchEndY = 0,
|
|
touchEndX = 0;
|
|
|
|
//extend default options
|
|
options = extend( defaults,config_options );
|
|
|
|
/**
|
|
* @exception {ConfigurationError} If conflicting scrolling options are set
|
|
*/
|
|
ConfigurationError.prototype = new Error();
|
|
ConfigurationError.prototype.constructor = ConfigurationError;
|
|
if (options.continuousVertical &&
|
|
(options.loopTop || options.loopBottom)) {
|
|
options.continuousVertical = false;
|
|
|
|
throw new ConfigurationError("Option loopTop/loopBottom is mutually exclusive with continuousVertical; continuousVertical disabled");
|
|
}
|
|
|
|
/** @throws Disable mutually exclusive settings */
|
|
if (scrollDelay < 400) {
|
|
options.continuousVertical = false;
|
|
|
|
throw new RangeError("BE CAREFUL! Not recommened to change it under 400 for a good behavior in laptops and Apple devices (laptops, mouses...)");
|
|
}
|
|
|
|
/** The current module configuration */
|
|
this.config = function(){
|
|
return options;
|
|
};
|
|
|
|
/** The current scroll delay setting */
|
|
this.scrollDelay = function(){
|
|
return scrollDelay;
|
|
};
|
|
|
|
/**
|
|
* set the scrolling behaviour
|
|
* @param {number} value
|
|
*/
|
|
this.setAutoScrolling = function(value){
|
|
options.autoScrolling = value; //el = document.getElementById( options.idSelector ), //sections = el.getElementsByClassName( options.sectionClass );
|
|
var element = document.getElementsByClassName('section active')[0],
|
|
docElemHTML = document.getElementsByTagName("html")[0],
|
|
docElemBody = document.getElementsByTagName("body")[0],
|
|
elementPosition = getPosition(element);
|
|
|
|
if(options.autoScrolling){
|
|
docElemHTML.style.overflow = 'hidden';
|
|
docElemHTML.style.height = '100%';
|
|
docElemBody.style.overflow = 'hidden';
|
|
docElemBody.style.height = '100%';
|
|
|
|
if(element.length){
|
|
//moving the container up
|
|
silentScroll(elementPosition.top);
|
|
}
|
|
}
|
|
else{
|
|
docElemHTML.style.overflow = 'auto';
|
|
docElemHTML.style.height = 'auto';
|
|
docElemBody.style.overflow = 'auto';
|
|
docElemBody.style.height = 'auto';
|
|
|
|
silentScroll(0);
|
|
|
|
//scrolling the page to the section with no animation
|
|
docElemHTML.scrollTop = elementPosition.top;
|
|
docElemBody.scrollTop = elementPosition.top;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Defines the scrolling speed
|
|
* @param {number} value - set the scrolling speed
|
|
*/
|
|
this.setScrollingSpeed = function(value){
|
|
options.scrollingSpeed = value;
|
|
};
|
|
|
|
/**
|
|
* Adds or remove the possiblity of scrolling through sections by using the keyboard arrow keys
|
|
* @param {number} value
|
|
*/
|
|
this.setKeyboardScrolling = function (value){
|
|
options.keyboardScrolling = value;
|
|
};
|
|
|
|
/**
|
|
* Adds or remove the possiblity of scrolling through sections by using the mouse wheel or the trackpad.
|
|
* @param {number} value
|
|
*/
|
|
this.setMouseWheelScrolling = function (value){
|
|
console.log('setMouseWheelScrolling',value);
|
|
if(value){
|
|
addMouseWheelHandler();
|
|
}else{
|
|
removeMouseWheelHandler();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Adds or remove the possiblity of scrolling through sections by using the mouse wheel/trackpad or touch gestures.
|
|
* @param {number} value
|
|
*/
|
|
this.setAllowScrolling = function (value){
|
|
if(value){
|
|
this.setMouseWheelScrolling(true);
|
|
addTouchHandler();
|
|
}
|
|
else{
|
|
this.setMouseWheelScrolling(false);
|
|
removeTouchHandler();
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Moves to previous section
|
|
*/
|
|
this.moveSectionUp = function(){
|
|
// console.log("moveSectionUp");
|
|
var prev = document.querySelector('.section.active').previousElementSibling;
|
|
// console.log("prev",prev);
|
|
if(prev && classie.hasClass(prev,'section')){
|
|
//looping to the bottom if there's no more sections above
|
|
if (!prev && (options.loopTop || options.continuousVertical)) {
|
|
prev = document.getElementsByClassName('section')[document.getElementsByClassName('section').length - 1];
|
|
}
|
|
|
|
if (prev) {
|
|
scrollPage(prev, null, true);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Moves to next section
|
|
*/
|
|
this.moveSectionDown = function (){
|
|
var next = document.querySelector('.section.active').nextElementSibling;
|
|
|
|
if(next && classie.hasClass(next,'section')){
|
|
//looping to the top if there's no more sections below
|
|
if(!next &&
|
|
(options.loopBottom || options.continuousVertical)){
|
|
next = document.getElementsByClassName('section')[0];//$('.section').first();
|
|
}
|
|
|
|
if(next){
|
|
scrollPage(next, null, false);
|
|
}
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Moves to specific section
|
|
* @param {number} section - number of section
|
|
* @param {number} slide - numder of slide
|
|
*/
|
|
this.moveTo = function (section, slide){
|
|
var destiny = '';
|
|
|
|
if(isNaN(section)){
|
|
destiny = document.querySelector('[data-anchor="'+section+'"]');
|
|
}else{
|
|
destiny = document.getElementsByClassName('section')[ (section -1) ];
|
|
}
|
|
|
|
if (typeof slide !== 'undefined'){
|
|
scrollPageAndSlide(section, slide);
|
|
}else if(destiny){
|
|
scrollPage(destiny);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* moves slide right
|
|
*/
|
|
this.moveSlideRight = function(){
|
|
moveSlide('next');
|
|
};
|
|
/**
|
|
* moves slide left
|
|
*/
|
|
this.moveSlideLeft = function(){
|
|
moveSlide('prev');
|
|
};
|
|
|
|
/**
|
|
* intialize a new linotype
|
|
*/
|
|
this.init = function(){
|
|
var docElemBody = document.getElementsByTagName('body')[0];
|
|
|
|
windowsHeight = document.documentElement.clientHeight;
|
|
linotypeElement = document.getElementById(options.idSelector);
|
|
container = linotypeElement;
|
|
|
|
//activate touch events
|
|
this.setAllowScrolling(true);
|
|
|
|
if(options.css3){
|
|
options.css3 = support3d();
|
|
}
|
|
|
|
if(linotypeElement){
|
|
container.style.height='100%';
|
|
container.style.position='relative';
|
|
container.style['-ms-touch-action']='none';
|
|
}
|
|
else{
|
|
var oldBodyHTML = document.getElementsByTagName('body')[0].innerHTML;
|
|
document.getElementsByTagName('body')[0].innerHTML='<div id="superContainer">'+oldBodyHTML+'</div>';
|
|
container = document.getElementById('superContainer');
|
|
}
|
|
|
|
//creating the navigation dots
|
|
if (options.navigation) {
|
|
var navHTML = document.createElement('div');
|
|
navHTML.innerHTML = "<ul></ul>";
|
|
navHTML.setAttribute("id", "fullPage-nav");
|
|
docElemBody.appendChild(navHTML);
|
|
|
|
var nav = document.getElementById("fullPage-nav");
|
|
nav.style.color = options.navigationColor;
|
|
classie.addClass(nav,options.navigationPosition);
|
|
}
|
|
|
|
var sections = container.getElementsByClassName('section');
|
|
for(var index = 0; index < sections.length; index++){
|
|
var that = sections[index];
|
|
var $this = sections[index];
|
|
var slides = ($this !== 'undefined') ? $this.getElementsByClassName('slide') : 0;
|
|
var numSlides = slides.length;
|
|
|
|
//if no active section is defined, the 1st one will be the default one
|
|
if(!index && document.getElementsByClassName('section active').length === 0) {
|
|
classie.addClass($this,'active');
|
|
}
|
|
|
|
if($this.style !== undefined){
|
|
$this.style.height = windowsHeight + 'px';
|
|
|
|
if(options.paddingTop || options.paddingBottom){
|
|
$this.style.padding = options.paddingTop + ' 0 ' + options.paddingBottom + ' 0';
|
|
}
|
|
|
|
if (typeof options.slidesColor[index] !== 'undefined') {
|
|
$this.style['background-color'] = options.slidesColor[index];
|
|
}
|
|
}
|
|
|
|
if (typeof options.anchors[index] !== 'undefined' && typeof $this === 'object' ) {
|
|
$this.setAttribute('data-anchor', options.anchors[index]);
|
|
}
|
|
|
|
if (options.navigation) {
|
|
var link = (options.anchors.length)? options.anchors[index]:'',
|
|
tooltip = (typeof options.navigationTooltips[index] !== 'undefined')? options.navigationTooltips[index] : '',
|
|
navToSetHTML = document.getElementById("fullPage-nav"),
|
|
navUL = navToSetHTML.getElementsByTagName('ul')[0],
|
|
newLIToAdd = document.createElement('li');
|
|
|
|
newLIToAdd.innerHTML='<a href="#' + link + '"><span></span></a></li>';
|
|
if(tooltip){
|
|
newLIToAdd.setAttribute('data-tooltip',tooltip);
|
|
}
|
|
navUL.appendChild(newLIToAdd);
|
|
}
|
|
|
|
// if there's any slide
|
|
if (numSlides > 0) {
|
|
var sliderWidth = numSlides * 100;
|
|
var slideWidth = 100 / numSlides;
|
|
var slidesContainerEl = document.createElement("div");
|
|
var slidesContainerForControlsEl = document.createElement("div");
|
|
slidesContainerEl.setAttribute('class','slidesContainer');
|
|
slidesContainerForControlsEl.setAttribute('class','slides');
|
|
|
|
elementContentWrapInner($this,slidesContainerEl);
|
|
|
|
elementContentWrapInner($this,slidesContainerForControlsEl);
|
|
|
|
$this.getElementsByClassName('slidesContainer')[0].style.width = sliderWidth + '%';
|
|
$this.innerHTML += '<div class="controlArrow prev"></div><div class="controlArrow next"></div>';
|
|
|
|
if(options.controlArrowColor!=='#fff'){
|
|
$this.getElementsByClassName('controlArrow next')[0].style['border-color'] = 'transparent transparent transparent '+options.controlArrowColor;
|
|
$this.getElementsByClassName('controlArrow prev')[0].style['border-color'] = 'transparent transparent transparent '+options.controlArrowColor;
|
|
}
|
|
|
|
if(!options.loopHorizontal){
|
|
elementHideCss($this.getElementsByClassName('controlArrow prev')[0]);
|
|
}
|
|
|
|
if(options.slidesNavigation){
|
|
addSlidesNavigation($this, numSlides);
|
|
}
|
|
|
|
for(var i = 0; i< numSlides;i++){
|
|
//if the slide won#t be an starting point, the default will be the first one
|
|
if(!i && $this.getElementsByClassName('slide active').length ===0){
|
|
classie.addClass($this.getElementsByClassName('slide')[0],'active');
|
|
}
|
|
|
|
$this.getElementsByClassName('slide')[i].style.width=slideWidth + '%';
|
|
|
|
if(options.verticalCentered){
|
|
addTableClass($this.getElementsByClassName('slide')[i]);
|
|
}
|
|
}
|
|
}
|
|
else{
|
|
if(options.verticalCentered){
|
|
addTableClass($this);
|
|
}
|
|
}
|
|
}
|
|
|
|
this.setup();
|
|
|
|
}.bind(this);
|
|
|
|
/**
|
|
* finalizing the module for events
|
|
*/
|
|
this.setup = function(){
|
|
this.setAutoScrolling(options.autoScrolling);
|
|
var nav = document.getElementById("fullPage-nav");
|
|
|
|
//the starting point is a slide?
|
|
var activeSlide = document.getElementsByClassName('section active')[0].getElementsByClassName(' slide active')[0];
|
|
|
|
// console.log("activeSlide",activeSlide);
|
|
if( typeof activeSlide !== 'undefined' && activeSlide.length &&
|
|
( nodelistToArray(document.getElementsByClassName('section'),true).indexOf(activeSlide.outerHTML)/* $('.section.active').index('.section')*/ !== 0 ||
|
|
( nodelistToArray(document.getElementsByClassName('section'),true).indexOf(activeSlide.outerHTML) /* $('.section.active').index('.section')*/ === 0 )/*&& activeSlide.index() !== 0 */)
|
|
){
|
|
var prevScrollingSpeepd = options.scrollingSpeed;
|
|
this.setScrollingSpeed(0);
|
|
landscapeScroll(document.getElementsByClassName('section active').getElementsByClassName('slides') , activeSlide);
|
|
this.setScrollingSpeed(prevScrollingSpeepd);
|
|
}
|
|
|
|
// //fixed elements need to be moved out of the plugin container due to problems with CSS3.
|
|
if(options.fixedElements && options.css3){
|
|
document.getElementsByTagName('body')[0].appendChild(document.querySelector(options.fixedElements));
|
|
}
|
|
|
|
//vertical centered of the navigation + first bullet active
|
|
if(options.navigation){
|
|
nav.style['margin-top'] = '-' + (nav.offsetHeight/2) + 'px';
|
|
var activeSection = nodelistToArray(document.getElementsByClassName('section'),true).indexOf(document.getElementsByClassName('section active')[0].outerHTML);
|
|
var navigationATag = nav.getElementsByTagName('li')[activeSection].getElementsByTagName('a')[0];
|
|
classie.addClass(navigationATag,'active');
|
|
}
|
|
|
|
//moving the menu outside the main container (avoid problems with fixed positions when using CSS3 tranforms)
|
|
if(options.menu && options.css3){
|
|
document.getElementsByTagName('body')[0].appendChild(document.querySelector(options.menu));
|
|
}
|
|
|
|
if(options.scrollOverflow){
|
|
//after DOM and images are loaded
|
|
// if (document.readyState === "complete") { init(); }
|
|
onWindowLoaded(function(){
|
|
var sections = document.getElementsByClassName('section');
|
|
for(var x=0; x < sections.length; x++){
|
|
var slides = sections[x].getElementsByClassName('slide');
|
|
var $this = sections[x];
|
|
|
|
if(slides.length){
|
|
for(var y=0; y< slides.length; y++){
|
|
// console.log(x,y,' slides');
|
|
createSlimScrolling(slides[y]);
|
|
}
|
|
|
|
}
|
|
else{
|
|
// console.log(x,'no slides');
|
|
createSlimScrolling($this);
|
|
}
|
|
}
|
|
if(typeof options.afterRender === "function"){
|
|
options.afterRender();
|
|
}
|
|
});
|
|
}
|
|
else{
|
|
if(typeof options.afterRender === "function"){
|
|
options.afterRender();
|
|
}
|
|
}
|
|
|
|
|
|
//getting the anchor link in the URL and deleting the `#`
|
|
var value = window.location.hash.replace('#', '').split('/');
|
|
var destiny = value[0];
|
|
|
|
if(destiny.length){
|
|
var section = document.querySelector('[data-anchor="'+destiny+'"]');
|
|
|
|
if(!options.animateAnchor && section.length){
|
|
silentScroll( getPosition(section).top);
|
|
if(typeof options.afterLoad === "function"){
|
|
options.afterLoad( destiny, (nodelistToArray(document.getElementsByClassName('section'),true).indexOf(section.outerHTML) + 1));
|
|
}
|
|
|
|
//updating the active class
|
|
var sectionColllection = document.getElementsByClassName('section');
|
|
for(var h =0; h <sectionColllection.length; h++){
|
|
classie.removeClass(sectionColllection[h],'active');
|
|
}
|
|
classie.addClass(section,'active');
|
|
}
|
|
}
|
|
|
|
onWindowLoaded(function() {
|
|
scrollToAnchor();
|
|
});
|
|
|
|
this.setupEventHandlers();
|
|
}.bind(this);
|
|
|
|
/**
|
|
* The current scroll delay setting
|
|
*/
|
|
this.setupEventHandlers = function(){
|
|
window.addEventListener("hashchange", windowOnHashChangeEvent, false);
|
|
window.addEventListener("scroll",windowScrollEvent, false);
|
|
window.addEventListener("onorientationchange",browserOnOrientationChange, false);
|
|
window.addEventListener("resize",windowResizeEvent, false);
|
|
|
|
document.addEventListener("keydown",keydownEvent,false);
|
|
var sections = document.querySelectorAll('.section');
|
|
for(var t =0; t<sections.length;t++){
|
|
sections[t].addEventListener("click",sectionClickEvent,false);
|
|
}
|
|
|
|
var navlinks = document.querySelectorAll('#fullPage-nav a');
|
|
for(var x =0; x<navlinks.length;x++){
|
|
navlinks[x].addEventListener("click",navigationClickEvent,false);
|
|
}
|
|
|
|
if(options.slidesNavigation){
|
|
document.querySelector('.fullPage-slidesNav').addEventListener('click',slideNavClickEvent,false);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Adds the possibility to auto scroll through sections on touch devices.
|
|
*/
|
|
function addTouchHandler(){
|
|
document.removeEventListener('touchstart');
|
|
document.removeEventListener('MSPointerDown');
|
|
document.addEventListener('touchstart',touchStartHandler,false);
|
|
document.addEventListener('MSPointerDown',touchStartHandler,false);
|
|
document.removeEventListener('touchmove');
|
|
document.removeEventListener('MSPointerMove');
|
|
document.addEventListener('touchmove',touchMoveHandler,false);
|
|
document.addEventListener('MSPointerMove',touchMoveHandler,false);
|
|
}
|
|
|
|
/**
|
|
* Removes the auto scrolling for touch devices.
|
|
*/
|
|
function removeTouchHandler(){
|
|
document.removeEventListener('touchmove MSPointerMove');
|
|
}
|
|
|
|
var elementHideCss = domhelper.elementHideCss;
|
|
var elementShowCss = domhelper.elementShowCss;
|
|
var elementContentWrapInner = domhelper.elementContentWrapInner;
|
|
var unwrapElement = domhelper.unwrapElement;
|
|
var onWindowLoaded = domhelper.onWindowLoaded;
|
|
var nodelistToArray = domhelper.nodelistToArray;
|
|
var closetElement = domhelper.closetElement;
|
|
var getParentElement = domhelper.getParentElement;
|
|
var insertAllBefore = domhelper.insertAllBefore;
|
|
var insertAllAfter = domhelper.insertAllAfter;
|
|
var getNextElements = domhelper.getNextElements;
|
|
var getPreviousElements = domhelper.getPreviousElements;
|
|
var nodeIndexOfNodeList = domhelper.nodeIndexOfNodeList;
|
|
var getScrollTop = domhelper.getScrollTop;
|
|
var removeAllClassAndToggle = domhelper.removeAllClassAndToggle;
|
|
var getElementSelector = domhelper.getElementSelector;
|
|
var getPosition = domhelper.getPosition;
|
|
|
|
function touchStartHandler(e){
|
|
var touchEvents = getEventsPage(e);
|
|
touchStartY = touchEvents.y;
|
|
touchStartX = touchEvents.x;
|
|
}
|
|
|
|
/**
|
|
* 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 = [];
|
|
if (window.navigator.msPointerEnabled){
|
|
events.y = e.pageY;
|
|
events.x = e.pageX;
|
|
}else{
|
|
events.y = e.touches[0].pageY;
|
|
events.x = e.touches[0].pageX;
|
|
}
|
|
return events;
|
|
}
|
|
|
|
/* 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.
|
|
*/
|
|
|
|
var touchMoveHandler = function(e){
|
|
// var e = event;
|
|
|
|
if(options.autoScrolling){
|
|
//preventing the easing on iOS devices
|
|
e.preventDefault();
|
|
}
|
|
|
|
// additional: if one of the normalScrollElements isn't within options.normalScrollElementTouchThreshold hops up the DOM chain
|
|
if (!checkParentForNormalScrollElement(e.target)) {
|
|
|
|
var touchMoved = false;
|
|
var activeSection = document.querySelector('.section.active');
|
|
var scrollable;
|
|
|
|
if (!isMoving && !slideMoving) { //if theres any #
|
|
var touchEvents = getEventsPage(e);
|
|
touchEndY = touchEvents.y;
|
|
touchEndX = touchEvents.x;
|
|
|
|
//if movement in the X axys is greater than in the Y and the currect section has slides...
|
|
if (activeSection.getElementsByClassName('slide').length && Math.abs(touchStartX - touchEndX) > (Math.abs(touchStartY - touchEndY))) {
|
|
|
|
//is the movement greater than the minimum resistance to scroll?
|
|
if (Math.abs(touchStartX - touchEndX) > (window.innerWidth / 100 * options.touchSensitivity)) {
|
|
if (touchStartX > touchEndX) {
|
|
this.moveSlideRight(); //next
|
|
} else {
|
|
this.moveSlideLeft(); //prev
|
|
}
|
|
}
|
|
}
|
|
|
|
//vertical scrolling (only when autoScrolling is enabled)
|
|
else if(options.autoScrolling){
|
|
|
|
//if there are landscape slides, we check if the scrolling bar is in the current one or not
|
|
if(activeSection.getElementsByClassName('slide').length){
|
|
scrollable= activeSection.querySelector('.slide.active').querySelector('.scrollable');
|
|
}else{
|
|
scrollable = activeSection.querySelector('.scrollable');
|
|
}
|
|
|
|
//is the movement greater than the minimum resistance to scroll?
|
|
if (Math.abs(touchStartY - touchEndY) > (window.innerHeight / 100 * options.touchSensitivity)) {
|
|
if (touchStartY > touchEndY) {
|
|
if(scrollable && scrollable.length > 0 ){
|
|
//is the scrollbar at the end of the scroll?
|
|
if(isScrolled('bottom', scrollable)){
|
|
this.moveSectionDown();
|
|
}else{
|
|
return true;
|
|
}
|
|
}else{
|
|
// moved down
|
|
this.moveSectionDown();
|
|
}
|
|
} else if (touchEndY > touchStartY) {
|
|
|
|
if(scrollable && scrollable.length > 0){
|
|
//is the scrollbar at the start of the scroll?
|
|
if(isScrolled('top', scrollable)){
|
|
this.moveSectionUp();
|
|
}
|
|
else{
|
|
return true;
|
|
}
|
|
}else{
|
|
// moved up
|
|
this.moveSectionUp();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}.bind(this);
|
|
|
|
/**
|
|
* recursive function to loop up the parent nodes to check if one of them exists in options.normalScrollElements
|
|
* Currently works well for iOS - Android might need some testing
|
|
* @param {Element} el target element / jquery selector (in subsequent nodes)
|
|
* @param {int} hop current hop compared to options.normalScrollElementTouchThreshold
|
|
* @return {boolean} true if there is a match to options.normalScrollElements
|
|
* @todo need to fix parent.isEqualNode to loop through selector of normalscrollelements called from @linotype~touchMoveHandler
|
|
*/
|
|
function checkParentForNormalScrollElement (el, hop) {
|
|
hop = hop || 0;
|
|
var parent = el.parentNode;
|
|
|
|
if (hop < options.normalScrollElementTouchThreshold &&
|
|
parent.isEqualNode(document.querySelector(options.normalScrollElements)) ) {
|
|
return true;
|
|
} else if (hop === options.normalScrollElementTouchThreshold) {
|
|
return false;
|
|
} else {
|
|
return checkParentForNormalScrollElement(parent, ++hop);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retuns `up` or `down` depending on the scrolling movement to reach its destination
|
|
* from the current section.
|
|
*/
|
|
function getYmovement(destiny){
|
|
var fromIndex = nodeIndexOfNodeList(document.getElementsByClassName('section'),document.getElementsByClassName('section active')[0]); //$('.section.active').index('.section');
|
|
var toIndex = nodeIndexOfNodeList(document.getElementsByClassName('section'),destiny);//destiny.index('.section');
|
|
|
|
if(fromIndex > toIndex){
|
|
return 'up';
|
|
}
|
|
return 'down';
|
|
}
|
|
|
|
/**
|
|
* 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';
|
|
}
|
|
|
|
/**
|
|
* Sliding with arrow keys, both, vertical and horizontal
|
|
*/
|
|
var keydownEvent = function(e){
|
|
console.log("keydownEvent",isMoving);
|
|
if (options.keyboardScrolling && !isMoving) {
|
|
switch (e.which) {
|
|
//up
|
|
case 38:
|
|
case 33:
|
|
this.moveSectionUp();
|
|
break;
|
|
|
|
//down
|
|
case 40:
|
|
case 34:
|
|
this.moveSectionDown();
|
|
break;
|
|
|
|
//left
|
|
case 37:
|
|
this.moveSlideLeft();
|
|
break;
|
|
|
|
//right
|
|
case 39:
|
|
this.moveSlideRight();
|
|
break;
|
|
|
|
default:
|
|
return; // exit this handler for other keys
|
|
}
|
|
}
|
|
}.bind(this);
|
|
|
|
/**
|
|
* Removes the auto scrolling action fired by the mouse wheel and tackpad.
|
|
* After this function is called, the mousewheel and trackpad movements won't scroll through sections.
|
|
*/
|
|
function removeMouseWheelHandler(){
|
|
if (document.addEventListener) {
|
|
document.removeEventListener('mousewheel', MouseWheelHandler, false); //IE9, Chrome, Safari, Oper
|
|
document.removeEventListener('wheel', MouseWheelHandler, false); //Firefox
|
|
} else {
|
|
document.detachEvent("onmousewheel", MouseWheelHandler); //IE 6/7/8
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Adds the auto scrolling action for the mouse wheel and tackpad.
|
|
* After this function is called, the mousewheel and trackpad movements will scroll through sections
|
|
*/
|
|
function addMouseWheelHandler(){
|
|
if (document.addEventListener) {
|
|
document.addEventListener("mousewheel", MouseWheelHandler, false); //IE9, Chrome, Safari, Oper
|
|
document.addEventListener("wheel", MouseWheelHandler, false); //Firefox
|
|
} else {
|
|
document.attachEvent("onmousewheel", MouseWheelHandler); //IE 6/7/8
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Detecting mousewheel scrolling
|
|
*
|
|
* http://blogs.sitepointstatic.com/examples/tech/mouse-wheel/index.html
|
|
* http://www.sitepoint.com/html5-javascript-mouse-wheel/
|
|
*/
|
|
var MouseWheelHandler = function (e){
|
|
/* jshint debug:true */
|
|
// debugger;
|
|
if(options.autoScrolling){
|
|
// cross-browser wheel delta
|
|
e = window.event || e;
|
|
var delta = Math.max(-1, Math.min(1,
|
|
(e.wheelDelta || -e.deltaY || -e.detail)));
|
|
var scrollable;
|
|
var activeSection = document.querySelector('.section.active');
|
|
|
|
if (!isMoving) { //if theres any #
|
|
|
|
//if there are landscape slides, we check if the scrolling bar is in the current one or not
|
|
if(activeSection.querySelectorAll('.slides').length){
|
|
console.log("has slides");
|
|
scrollable= activeSection.querySelector('.slide.active').querySelector('.scrollable');
|
|
}else{
|
|
console.log("on section");
|
|
scrollable = activeSection.querySelector('.scrollable');
|
|
// console.log("scrollable.length",(typeof scrollable.length));
|
|
}
|
|
|
|
//scrolling down?
|
|
if (delta < 0) {
|
|
if(scrollable){
|
|
//is the scrollbar at the end of the scroll?
|
|
if(isScrolled('bottom', scrollable)){
|
|
this.moveSectionDown();
|
|
}else{
|
|
return true; //normal scroll
|
|
}
|
|
}else{
|
|
this.moveSectionDown();
|
|
}
|
|
}
|
|
|
|
//scrolling up?
|
|
else {
|
|
if(scrollable){
|
|
//is the scrollbar at the start of the scroll?
|
|
if(isScrolled('top', scrollable)){
|
|
this.moveSectionUp();
|
|
}else{
|
|
return true; //normal scroll
|
|
}
|
|
}else{
|
|
this.moveSectionUp();
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}.bind(this);
|
|
|
|
/** handle updating window hash location */
|
|
function windowOnHashChangeEvent(e){
|
|
if(!isScrolling){
|
|
var value = window.location.hash.replace('#', '').split('/');
|
|
var section = value[0];
|
|
var slide = value[1];
|
|
|
|
//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 lastScrolledDestiny === 'undefined');
|
|
var isFirstScrollMove = (typeof lastScrolledDestiny === 'undefined' && typeof slide === 'undefined');
|
|
|
|
/*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 ((section && section !== lastScrolledDestiny) && !isFirstSlideMove || isFirstScrollMove || (!slideMoving && lastScrolledSlide !== slide )) {
|
|
scrollPageAndSlide(section, slide);
|
|
}
|
|
}
|
|
}
|
|
|
|
//window scroll event
|
|
function windowScrollEvent(e){
|
|
// console.log("window scroll");
|
|
var allSections = document.getElementsByClassName('section');
|
|
if(!options.autoScrolling){
|
|
var currentScroll = getScrollTop(window);
|
|
|
|
var scrolledSections = [];
|
|
|
|
nodelistToArray(document.querySelectorAll('.section')).map(function(mapIndex,index,arr){
|
|
var $this = mapIndex;
|
|
if ($this.offsetTop< (currentScroll + 100)){
|
|
if($this){scrolledSections.push($this);}
|
|
}
|
|
});
|
|
|
|
//geting the last one, the current one on the screen
|
|
var currentSectionIndex = scrolledSections.length-1;
|
|
var currentSection = scrolledSections[currentSectionIndex];
|
|
// console.log("currentSection",currentSection);
|
|
|
|
//executing only once the first time we reach the section
|
|
if(!classie.hasClass(currentSection,'active')){
|
|
var leavingSection =nodeIndexOfNodeList(document.getElementsByClassName('section'),document.querySelector('.section.active')) +1;
|
|
|
|
isScrolling = true;
|
|
|
|
var yMovement = getYmovement(currentSection);
|
|
|
|
removeAllClassAndToggle(currentSection,allSections,'active');
|
|
|
|
var anchorLink = currentSection.getAttribute('data-anchor');
|
|
if(typeof options.onLeave ==='function'){
|
|
options.onLeave.call(leavingSection, (currentSectionIndex + 1), yMovement);
|
|
}
|
|
|
|
activateMenuElement(anchorLink);
|
|
activateNavDots(anchorLink, 0);
|
|
|
|
if(options.anchors.length && !isMoving){
|
|
//needed to enter in hashChange event when using the menu with anchor links
|
|
lastScrolledDestiny = anchorLink;
|
|
|
|
location.hash = anchorLink;
|
|
}
|
|
|
|
//small timeout in order to avoid entering in hashChange event when scrolling is not finished yet
|
|
clearTimeout(scrollId);
|
|
scrollId = setTimeout(function(){
|
|
isScrolling = false;
|
|
}, 100);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
//navigation action
|
|
function navigationClickEvent(e){
|
|
e.preventDefault();
|
|
var atarget = e.target.parentNode.parentNode;
|
|
var allNavTargets = e.target.parentNode.parentNode.parentNode.children;
|
|
var index = nodeIndexOfNodeList(allNavTargets,atarget);
|
|
|
|
scrollPage(document.getElementsByClassName('section')[index]);
|
|
}
|
|
|
|
//slidenav click event
|
|
function slideNavClickEvent(e){
|
|
e.preventDefault();
|
|
var etarget = e.target;
|
|
|
|
if(etarget.tagName==='SPAN'){
|
|
var slides = document.querySelector('.section.active').querySelectorAll('.slide'),
|
|
destiny;
|
|
var slideLI = etarget.parentNode.parentNode;
|
|
var allSlidesLI = etarget.parentNode.parentNode.parentNode.children;
|
|
classie.addClass(slideLI,'clickedTarget');
|
|
destiny = slides[nodeIndexOfNodeList(allSlidesLI,slideLI)];
|
|
classie.removeClass(slideLI,'clickedTarget');
|
|
|
|
landscapeScroll(slides,destiny);
|
|
}
|
|
}
|
|
|
|
//click events
|
|
var sectionClickEvent = function(e){
|
|
var eventTarget = e.target;
|
|
|
|
if(classie.hasClass(eventTarget,'controlArrow')){
|
|
if(classie.hasClass(eventTarget,'prev')){
|
|
this.moveSlideLeft();
|
|
}
|
|
else{
|
|
this.moveSlideRight();
|
|
}
|
|
}
|
|
else if(classie.hasClass(eventTarget,'toSlide')){
|
|
e.preventDefault();
|
|
|
|
console.log("toSlide");
|
|
// var slides = $(this).closest('.section').find('.slides');
|
|
// var currentSlide = slides.find('.slide.active');
|
|
// var destiny = null;
|
|
|
|
// destiny = slides.find('.slide').eq( ($(this).data('index') -1) );
|
|
|
|
// if(destiny.length > 0){
|
|
// landscapeScroll(slides, destiny);
|
|
// }
|
|
}
|
|
}.bind(this);
|
|
|
|
//window resize event
|
|
function windowResizeEvent(e){
|
|
clearTimeout(resizeTimeout);
|
|
resizeTimeout = setTimeout(doneResizing, 500);
|
|
}
|
|
|
|
//mobile orientation change
|
|
function browserOnOrientationChange(e){
|
|
console.log("browserOnOrientationChange");
|
|
doneResizing();
|
|
}
|
|
|
|
/**
|
|
* When resizing is finished, we adjust the slides sizes and positions
|
|
*/
|
|
function doneResizing() {
|
|
isResizing = true;
|
|
|
|
var windowsWidth = window.innerWidth;
|
|
windowsHeight = window.innerHeight;
|
|
|
|
//text and images resizing
|
|
if (options.resize) {
|
|
resizeMe(windowsHeight, windowsWidth);
|
|
}
|
|
|
|
var allSections = document.getElementsByClassName('section');
|
|
for(var x = 0; x <allSections.length; x++){
|
|
var $this = allSections[x],
|
|
scrollHeight = getScrollHeight($this),
|
|
slides = $this.querySelectorAll('.slide');
|
|
|
|
//adjusting the height of the table-cell for IE and Firefox
|
|
if(options.verticalCentered){
|
|
$this.querySelector('.tableCell').style.height = getTableHeight($this) + 'px';
|
|
}
|
|
|
|
$this.style.height = windowsHeight + 'px';
|
|
|
|
//resizing the scrolling divs
|
|
if(options.scrollOverflow){
|
|
|
|
if(slides.length){
|
|
for(var y=0; y< slides.length; y++){
|
|
// console.log(x,y,' slides');
|
|
createSlimScrolling(slides[y]);
|
|
}
|
|
}else{
|
|
createSlimScrolling($this);
|
|
}
|
|
}
|
|
|
|
//adjusting the position fo the FULL WIDTH slides...
|
|
if (slides.length) {
|
|
landscapeScroll(slides, $this.querySelector('.slide.active'));
|
|
}
|
|
}
|
|
|
|
//adjusting the position for the current section
|
|
var activeSection = document.querySelector('.section.active');
|
|
var destinyPos = getPosition(activeSection);
|
|
|
|
//isn't it the first section?
|
|
if(nodeIndexOfNodeList(allSections,activeSection)){
|
|
scrollPage(activeSection);
|
|
}
|
|
|
|
isResizing = false;
|
|
if(typeof options.afterResize ==='function') {options.afterResize.call();}
|
|
}
|
|
|
|
/**
|
|
* Resizing of the font size depending on the window size as well as some of the images on the site.
|
|
*/
|
|
function resizeMe(displayHeight, displayWidth) {
|
|
//Standard height, for which the body font size is correct
|
|
var preferredHeight = 825;
|
|
var windowSize = displayHeight;
|
|
|
|
/* Problem to be solved
|
|
|
|
if (displayHeight < 825) {
|
|
var percentage = (windowSize * 100) / preferredHeight;
|
|
var newFontSize = percentage.toFixed(2);
|
|
|
|
$("img").each(function() {
|
|
var newWidth = ((80 * percentage) / 100).toFixed(2);
|
|
$(this).css("width", newWidth + '%');
|
|
});
|
|
} else {
|
|
$("img").each(function() {
|
|
$(this).css("width", '');
|
|
});
|
|
}*/
|
|
|
|
if (displayHeight < 825 || displayWidth < 900) {
|
|
// console.log("displayHeight",displayHeight);
|
|
// console.log("displayWidth",displayWidth);
|
|
if (displayWidth < 900) {
|
|
windowSize = displayWidth;
|
|
preferredHeight = 900;
|
|
}
|
|
var percentage = (windowSize * 100) / preferredHeight;
|
|
var newFontSize = percentage.toFixed(2);
|
|
// console.log("percentage",percentage);
|
|
// console.log("newFontSize",newFontSize);
|
|
|
|
document.getElementsByTagName("body")[0].style["font-size"] = newFontSize + '%';
|
|
} else {
|
|
// console.log("displayHeight",displayHeight);
|
|
// console.log("displayWidth",displayWidth);
|
|
document.getElementsByTagName("body")[0].style["font-size"] = '100%';
|
|
}
|
|
}
|
|
|
|
function scrollToAnchor(){
|
|
//getting the anchor link in the URL and deleting the `#`
|
|
var value = window.location.hash.replace('#', '').split('/');
|
|
var section = value[0];
|
|
var slide = value[1];
|
|
|
|
if(section){ //if theres any #
|
|
scrollPageAndSlide(section, slide);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Scrolls to the given section and slide
|
|
*/
|
|
function scrollPageAndSlide(destiny, slide){
|
|
// console.log("scrollPageAndSlide");
|
|
var section;
|
|
if (typeof slide === 'undefined') {
|
|
slide = 0;
|
|
}
|
|
|
|
if(isNaN(destiny)){
|
|
section = document.querySelector('[data-anchor="'+destiny+'"]');
|
|
}
|
|
else{
|
|
section = document.getElementsByClassName('section')[(destiny -1)];
|
|
}
|
|
|
|
if(section){
|
|
//we need to scroll to the section and then to the slide
|
|
if (destiny !== lastScrolledDestiny && !classie.hasClass(section,'active')){
|
|
scrollPage(section, function(){
|
|
scrollSlider(section, slide);
|
|
});
|
|
}
|
|
//if we were already in the section
|
|
else{
|
|
scrollSlider(section, slide);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Scrolls the slider to the given slide destination for the given section
|
|
*/
|
|
function scrollSlider(section, slide){
|
|
if(typeof slide !== 'undefined' && slide !== 0){
|
|
var slides = section.querySelectorAll('.slide');
|
|
var destiny = section.querySelector('.slides').querySelector('[data-anchor="'+slide+'"]');
|
|
if(!destiny){
|
|
destiny = section.querySelectorAll('.slide')[slide];
|
|
}
|
|
|
|
if(destiny){
|
|
landscapeScroll(slides, destiny);
|
|
}
|
|
}
|
|
}
|
|
|
|
function moveSlide(direction){
|
|
var activeSection = document.querySelector('.section.active');
|
|
var slides = activeSection.getElementsByClassName('slide');
|
|
|
|
// more than one slide needed and nothing should be sliding
|
|
if (!slides.length || slideMoving) {
|
|
return;
|
|
}
|
|
|
|
var currentSlide = activeSection.querySelector('.slide.active');
|
|
var destiny = null;
|
|
|
|
if(direction === 'prev'){
|
|
destiny = currentSlide.previousElementSibling;
|
|
}else{
|
|
destiny = currentSlide.nextElementSibling;
|
|
}
|
|
|
|
//isn't there a next slide in the secuence?
|
|
if(!destiny){
|
|
//respect loopHorizontal settin
|
|
if (!options.loopHorizontal) {return;}
|
|
|
|
if(direction === 'prev'){
|
|
destiny = currentSlide.parentNode.lastElementChild;// currentSlide.siblings(':last');
|
|
}else{
|
|
destiny = currentSlide.parentNode.firstElementChild;//currentSlide.siblings(':first');
|
|
}
|
|
}
|
|
|
|
slideMoving = true;
|
|
|
|
landscapeScroll(slides, destiny);
|
|
}
|
|
|
|
function scrollPage(element, callback, isMovementUp){
|
|
var scrollOptions = {}, scrolledElement,
|
|
dest = getPosition(element);
|
|
|
|
if(typeof dest === "undefined"){ return; } //there's no element to scroll, leaving the function
|
|
/** @todo TODO: why does dest.bottom === jquery.position().top */
|
|
var dtop = dest.top,
|
|
yMovement = getYmovement(element),
|
|
anchorLink = element.getAttribute('data-anchor'),
|
|
sectionIndex = nodelistToArray(document.getElementsByClassName('section'),true).indexOf(element.outerHTML), ///element.index('.section');
|
|
activeSlide = element.querySelector('.slide.active'),
|
|
activeSection = document.querySelector('.section.active'),
|
|
leavingSection = nodelistToArray(document.getElementsByClassName('section'),true).indexOf(activeSection.outerHTML) +1,//activeSection.index('.section') + 1;
|
|
slideAnchorLink = null,
|
|
slideIndex = null,
|
|
localIsResizing = isResizing;//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
|
|
|
|
|
|
|
|
if(activeSlide !== null){
|
|
slideAnchorLink = activeSlide.getAttribute('data-anchor');
|
|
slideIndex = nodelistToArray(element.getElementsByClassName('slide'),true).indexOf(activeSlide.outerHTML);//activeSlide.index();
|
|
}
|
|
// console.log("slideIndex",slideIndex);
|
|
|
|
// If continuousVertical && we need to wrap around
|
|
if (options.autoScrolling && options.continuousVertical && typeof (isMovementUp) !== "undefined" &&
|
|
((!isMovementUp && yMovement === 'up') || // Intending to scroll down but about to go up or
|
|
(isMovementUp && yMovement === 'down'))) { // intending to scroll up but about to go down
|
|
|
|
// Scrolling down
|
|
if (!isMovementUp) {
|
|
// Move all previous sections to after the active section
|
|
var muarray =[];
|
|
insertAllAfter(activeSection,getPreviousElements(activeSection,muarray).reverse());
|
|
// $(".section.active").after(activeSection.prevAll(".section").get().reverse());
|
|
}
|
|
else { // Scrolling up
|
|
// Move all next sections to before the active section
|
|
var mdarray =[];
|
|
insertAllBefore(activeSection,getNextElements(activeSection,mdarray));
|
|
// $(".section.active").before(activeSection.nextAll(".section"));
|
|
}
|
|
|
|
// Maintain the displayed position (now that we changed the element order)
|
|
silentScroll(getPosition(activeSection).top);
|
|
|
|
// save for later the elements that still need to be reordered
|
|
var wrapAroundElements = activeSection;
|
|
|
|
// Recalculate animation variables
|
|
dest = getPosition(element);
|
|
dtop = dest.top;
|
|
yMovement = getYmovement(element);
|
|
}
|
|
|
|
var elementCol = document.getElementsByClassName('section');
|
|
removeAllClassAndToggle(element,elementCol,'active');
|
|
|
|
//preventing from activating the MouseWheelHandler event
|
|
//more than once if the page is scrolling
|
|
isMoving = true;
|
|
|
|
if(typeof anchorLink !== 'undefined'){
|
|
setURLHash(slideIndex, slideAnchorLink, anchorLink);
|
|
}
|
|
|
|
if(options.autoScrolling){
|
|
scrollOptions.top = -dtop;
|
|
scrolledElement = getElementSelector(container);
|
|
}else{
|
|
scrollOptions.scrollTop = dtop;
|
|
scrolledElement = 'html, body';
|
|
}
|
|
|
|
// Fix section order after continuousVertical changes have been animated
|
|
var continuousVerticalFixSectionOrder = function () {
|
|
// 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 (!wrapAroundElements || !wrapAroundElements.length) {
|
|
return;
|
|
}
|
|
|
|
if (isMovementUp) {
|
|
insertAllBefore(document.querySelector('.section').parentNode.firstElementChild,wrapAroundElements);
|
|
// $('.section:first').before(wrapAroundElements);
|
|
}
|
|
else {
|
|
insertAllAfter(document.querySelector('.section').parentNode.lastElementChild,wrapAroundElements);
|
|
// $('.section:last').after(wrapAroundElements);
|
|
}
|
|
|
|
silentScroll(getPosition(activeSection).top);
|
|
};
|
|
|
|
// Use CSS3 translate functionality or...
|
|
if (options.css3 && options.autoScrolling) {
|
|
|
|
console.log("translate css3");
|
|
|
|
//callback (onLeave) if the site is not just resizing and readjusting the slides
|
|
if((typeof options.onLeave ==='function') && !localIsResizing ){
|
|
options.onLeave.call(leavingSection, (sectionIndex + 1), yMovement);
|
|
}
|
|
|
|
classie.addClass( container, 'easing' );
|
|
var translate3d = 'translate3d(0px, -' + dtop + 'px, 0px)';
|
|
transformContainer(translate3d, true);
|
|
|
|
var t = setTimeout(function () {
|
|
//fix section order from continuousVertical
|
|
continuousVerticalFixSectionOrder();
|
|
//callback (afterLoad) if the site is not just resizing and readjusting the slides
|
|
if((typeof options.afterLoad ==='function') && !localIsResizing) {
|
|
options.afterLoad( anchorLink, (sectionIndex + 1));
|
|
}
|
|
|
|
setTimeout(function () {
|
|
isMoving = false;
|
|
if(typeof callback ==='function'){
|
|
callback(this);
|
|
}
|
|
}, scrollDelay);
|
|
}, options.scrollingSpeed);
|
|
}
|
|
else { // ... use jQuery animate
|
|
console.log("no css3 sub jquery animate");
|
|
//callback (onLeave) if the site is not just resizing and readjusting the slides
|
|
if((typeof options.onLeave ==='function') && !localIsResizing){
|
|
options.onLeave.call(leavingSection, (sectionIndex + 1), yMovement);
|
|
}
|
|
|
|
container.style.top = -dtop+'px';
|
|
//fix section order from continuousVertical
|
|
continuousVerticalFixSectionOrder();
|
|
|
|
//callback (afterLoad) if the site is not just resizing and readjusting the slides
|
|
if((typeof options.afterLoad ==='function') && !localIsResizing){
|
|
options.afterLoad( anchorLink, (sectionIndex + 1));
|
|
}
|
|
|
|
setTimeout(function () {
|
|
isMoving = false;
|
|
if(typeof callback ==='function'){callback(this);}
|
|
}, scrollDelay);
|
|
}
|
|
|
|
//flag to avoid callingn `scrollPage()` twice in case of using anchor links
|
|
lastScrolledDestiny = anchorLink;
|
|
|
|
//avoid firing it twice (as it does also on scroll)
|
|
if(options.autoScrolling){
|
|
activateMenuElement(anchorLink);
|
|
activateNavDots(anchorLink, sectionIndex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the URL hash for a section with slides
|
|
* @private
|
|
*/
|
|
function setURLHash(slideIndex, slideAnchor, anchorLink){
|
|
var sectionHash = '';
|
|
|
|
if(options.anchors.length){
|
|
|
|
//isn't it the first slide?
|
|
if(slideIndex){
|
|
if(typeof anchorLink !== 'undefined'){
|
|
sectionHash = anchorLink;
|
|
}
|
|
|
|
//slide without anchor link? We take the index instead.
|
|
if(typeof slideAnchor === 'undefined'){
|
|
slideAnchor = slideIndex;
|
|
}
|
|
|
|
lastScrolledSlide = slideAnchor;
|
|
location.hash = sectionHash + '/' + slideAnchor;
|
|
|
|
//first slide won't have slide anchor, just the section one
|
|
}else if(typeof slideIndex !== 'undefined'){
|
|
lastScrolledSlide = slideAnchor;
|
|
location.hash = anchorLink;
|
|
}
|
|
|
|
//section without slides
|
|
else{
|
|
location.hash = anchorLink;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Activating the website navigation dots according to the given slide name.
|
|
*/
|
|
function activateNavDots(name, sectionIndex){
|
|
if(options.navigation){
|
|
var fullpageNavID = document.getElementById('fullPage-nav');
|
|
classie.removeClass(fullpageNavID.querySelector('.active'),'active');
|
|
if(name){
|
|
classie.addClass(fullpageNavID.querySelector('a[href="#' + name + '"]'),'active');
|
|
}
|
|
else{
|
|
classie.addClass(fullpageNavID.querySelector('li')[sectionIndex].querySelector('a'),'active');
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return a boolean depending on whether the scrollable element is at the end or at the start of the scrolling
|
|
* depending on the given type.
|
|
*/
|
|
function isScrolled(type, scrollable){
|
|
if(type === 'top'){
|
|
return !scrollable.scrollTop;
|
|
}else if(type === 'bottom'){
|
|
return scrollable.scrollTop + container.offsetHeight >= scrollable.scrollHeight;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Activating the website main menu elements according to the given slide name.
|
|
*/
|
|
function activateMenuElement(name){
|
|
if(options.menu){
|
|
if(document.querySelector(options.menu).querySelector('.active')){
|
|
classie.removeClass(document.querySelector(options.menu).querySelector('.active'),'active');
|
|
}
|
|
classie.addClass(document.querySelector(options.menu).querySelector('[data-menuanchor="'+name+'"]'),'active');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* createSlimScrolling
|
|
*/
|
|
function createSlimScrolling(element){
|
|
var section, sectionPaddingTop=0, sectionPaddingBottom=0;
|
|
//needed to make `scrollHeight` work under Opera 12
|
|
element.style.overflow = 'hidden';
|
|
//in case element is a slide
|
|
if(element.className.match(/slide/gi)){
|
|
var parentSectionOfSlide = getParentElement(element,'section');
|
|
// console.log("slide section:",parentSectionOfSlide);
|
|
section = parentSectionOfSlide;//closetElement(parentSectionOfSlide);
|
|
}
|
|
else{
|
|
section = element;//closetElement(element);
|
|
}
|
|
var scrollable = element.getElementsByClassName('scrollable'),contentHeight;
|
|
|
|
//if there was scroll, the contentHeight will be the one in the scrollable section
|
|
if(scrollable.length){
|
|
contentHeight = element.getElementsByClassName('scrollable')[0].scrollHeight;
|
|
}
|
|
else{
|
|
if(options.verticalCentered){
|
|
contentHeight = element.getElementsByClassName('tableCell')[0].scrollHeight;
|
|
}
|
|
}
|
|
|
|
var scrollHeight = getScrollHeight(section);
|
|
|
|
//needs scroll?
|
|
if ( contentHeight > scrollHeight) {
|
|
//was there already an scroll ? Updating it
|
|
if(scrollable.length){
|
|
scrollable[0].style.height= scrollHeight + 'px';
|
|
scrollable[0].parentNode.style.height= scrollHeight + 'px';
|
|
}
|
|
//creating the scrolling
|
|
else{
|
|
var scrollableEl = document.createElement("div");
|
|
scrollableEl.setAttribute('class','scrollable');
|
|
|
|
if(options.verticalCentered){
|
|
elementContentWrapInner(element.querySelector('.tableCell'),scrollableEl);
|
|
}else{
|
|
elementContentWrapInner(element,scrollableEl);
|
|
}
|
|
var ss = new Slimscroll({
|
|
height: scrollHeight + 'px',
|
|
size: '10px',
|
|
alwaysVisible: true
|
|
},element.getElementsByClassName('scrollable'));
|
|
ss.init();
|
|
// element.find('.scrollable').slimScroll({
|
|
// height: scrollHeight + 'px',
|
|
// size: '10px',
|
|
// alwaysVisible: true
|
|
// });
|
|
}
|
|
}
|
|
//removing the scrolling when it is not necessary anymore
|
|
else{
|
|
if(element.getElementsByClassName('scrollable').children){
|
|
var scrollablefc = element.getElementsByClassName('scrollable').children.firstChild;
|
|
unwrapElement(scrollablefc);
|
|
unwrapElement(scrollablefc);
|
|
// element.find('.scrollable').children().first().unwrap().unwrap();
|
|
}
|
|
if(element.getElementsByClassName('slimScrollBar').parentNode){
|
|
// element.find('.slimScrollBar').remove();
|
|
var slimScrollBar = element.getElementsByClassName('slimScrollBar');
|
|
slimScrollBar.parentNode.removeChild(slimScrollBar);
|
|
}
|
|
if(element.getElementsByClassName('slimScrollRail').parentNode){
|
|
// element.find('.slimScrollRail').remove();
|
|
var slimScrollRail = element.getElementsByClassName('slimScrollRail');
|
|
slimScrollRail.parentNode.removeChild(slimScrollRail);
|
|
}
|
|
}
|
|
//undo
|
|
element.style.overflow='';
|
|
}
|
|
|
|
function getScrollHeight(element){
|
|
var windowsHeight = window.innerHeight,
|
|
sectionPaddingBottom = (element.style['padding-bottom'])? parseInt(element.style['padding-bottom'],10) :0,
|
|
sectionPaddingTop = (element.style['padding-top'])? parseInt(element.style['padding-top'],10) :0;
|
|
return (windowsHeight - sectionPaddingBottom - sectionPaddingTop);
|
|
}
|
|
|
|
/**
|
|
* Scrolls horizontal sliders.
|
|
*/
|
|
function landscapeScroll(slides, destiny){
|
|
// console.log("landscapeScroll");
|
|
var destinyPos = getPosition(destiny),
|
|
slidesContainer = destiny.parentNode,
|
|
slideIndex = nodeIndexOfNodeList(slides,destiny),
|
|
section = getParentElement(destiny,'section'),
|
|
sectionIndex = nodeIndexOfNodeList(document.getElementsByClassName('section'),section),
|
|
anchorLink = section.getAttribute('data-anchor'),
|
|
slidesNav = section.querySelector('.fullPage-slidesNav'),
|
|
slideAnchor = destiny.getAttribute('data-anchor');
|
|
|
|
//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
|
|
var localIsResizing = isResizing;
|
|
|
|
if(options.onSlideLeave){
|
|
var prevSlideIndex = nodeIndexOfNodeList(section.querySelectorAll('.slide'),section.querySelector('.slide.active'));
|
|
var xMovement = getXmovement(prevSlideIndex, slideIndex);
|
|
|
|
//if the site is not just resizing and readjusting the slides
|
|
if(!localIsResizing){
|
|
if(typeof options.onSlideLeave ==='function' ){
|
|
options.onSlideLeave.call( anchorLink, (sectionIndex + 1), prevSlideIndex, xMovement);
|
|
}
|
|
}
|
|
}
|
|
|
|
var elementCol = section.getElementsByClassName('slide');
|
|
removeAllClassAndToggle(destiny,elementCol,'active');
|
|
|
|
if(typeof slideAnchor === 'undefined' || slideAnchor === null){
|
|
slideAnchor = slideIndex;
|
|
}
|
|
|
|
//only changing the URL if the slides are in the current section (not for resize re-adjusting)
|
|
if(classie.hasClass(section,'active')){
|
|
|
|
if(!options.loopHorizontal){
|
|
var prevarrow =section.querySelector('.controlArrow.prev'),
|
|
nextarrow = section.querySelector('.controlArrow.next');
|
|
//hidding it for the fist slide, showing for the rest
|
|
if(slideIndex!==0){
|
|
elementShowCss(prevarrow);
|
|
}
|
|
else{
|
|
elementHideCss(prevarrow);
|
|
}
|
|
|
|
//hidding it for the last slide, showing for the rest
|
|
if(nodeIndexOfNodeList(elementCol,destiny) === elementCol.length-1){
|
|
elementHideCss(nextarrow);
|
|
}
|
|
else{
|
|
elementShowCss(nextarrow);
|
|
}
|
|
}
|
|
|
|
setURLHash(slideIndex, slideAnchor, anchorLink);
|
|
|
|
}
|
|
|
|
if(options.css3){
|
|
var translate3d = 'translate3d(-' + destinyPos.left + 'px, 0px, 0px)';
|
|
|
|
// slides.find('.slidesContainer').toggleClass('easing', options.scrollingSpeed>0).css(getTransforms(translate3d));
|
|
|
|
classie.addClass( slidesContainer, 'easing' );
|
|
transformElement( translate3d, slidesContainer);
|
|
|
|
setTimeout(function(){
|
|
//if the site is not just resizing and readjusting the slides
|
|
if(!localIsResizing){
|
|
if(typeof options.afterSlideLoad ==='function'){ options.afterSlideLoad.call( this, anchorLink, (sectionIndex + 1), slideAnchor, slideIndex );
|
|
}
|
|
}
|
|
|
|
slideMoving = false;
|
|
}, options.scrollingSpeed, options.easing);
|
|
}else{
|
|
console.log("no css3 sub jquery animate");
|
|
|
|
slidesContainer.style.scrollLeft = destinyPos.left;
|
|
|
|
//if the site is not just resizing and readjusting the slides
|
|
if(!localIsResizing){
|
|
if(typeof options.afterSlideLoad ==='function' ){ options.afterSlideLoad.call( anchorLink, (sectionIndex + 1), slideAnchor, slideIndex);}
|
|
}
|
|
//letting them slide again
|
|
slideMoving = false;
|
|
}
|
|
|
|
if(options.slidesNavigation){
|
|
classie.removeClass(slidesNav.querySelector('.active'),'active');
|
|
classie.addClass(slidesNav.querySelectorAll('li')[slideIndex].querySelector('a'),'active');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a landscape navigation bar with dots for horizontal sliders.
|
|
@private
|
|
@param {object} section - nodeelement to add navigation to
|
|
@param {number} numSlides - number of slides
|
|
*/
|
|
function addSlidesNavigation(section, numSlides){
|
|
section.innerHTML+= '<div class="fullPage-slidesNav"><ul></ul></div>';
|
|
var nav = section.getElementsByClassName('fullPage-slidesNav')[0];
|
|
|
|
//top or bottom
|
|
classie.addClass(nav,options.slidesNavPosition);
|
|
|
|
for(var i=0; i< numSlides; i++){
|
|
nav.getElementsByTagName('ul')[0].innerHTML+='<li><a href="#"><span></span></a></li>';
|
|
}
|
|
|
|
//centering it
|
|
nav.style['margin-left'] = '-' + (nav.offsetWidth/2) + 'px';
|
|
classie.addClass(nav.getElementsByTagName('li')[0].getElementsByTagName('a')[0],'active');
|
|
}
|
|
|
|
/**
|
|
* adds table style to section
|
|
* @private
|
|
* @param { string } element - document element
|
|
*/
|
|
function addTableClass(element){
|
|
classie.addClass(element,'table');
|
|
var slidesTableContainerEl = document.createElement("div");
|
|
slidesTableContainerEl.setAttribute('class','tableCell');
|
|
slidesTableContainerEl.setAttribute('style',"height:" + getTableHeight(element) + "px;");
|
|
|
|
elementContentWrapInner(element,slidesTableContainerEl);
|
|
}
|
|
|
|
/**
|
|
* get height for table
|
|
* @private
|
|
* @param { string } element - document element
|
|
*/
|
|
function getTableHeight(element){
|
|
var sectionHeight = windowsHeight;
|
|
|
|
if(options.paddingTop || options.paddingBottom){
|
|
var section = element;
|
|
if(!classie.hasClass(section,'section')){
|
|
section = element.closest('.section');
|
|
}
|
|
|
|
var sectionPaddingBottom = (element.style['padding-bottom'])? parseInt(element.style['padding-bottom'],10) :0,
|
|
sectionPaddingTop = (element.style['padding-top'])? parseInt(element.style['padding-top'],10) :0;
|
|
sectionHeight = (windowsHeight - sectionPaddingBottom - sectionPaddingTop);
|
|
}
|
|
|
|
return sectionHeight;
|
|
}
|
|
|
|
/**
|
|
* Checks for translate3d support
|
|
* @return boolean
|
|
* http://stackoverflow.com/questions/5661671/detecting-transform-translate3d-support
|
|
*/
|
|
function support3d() {
|
|
var el = document.createElement('p'),
|
|
has3d,
|
|
transforms = {
|
|
'webkitTransform':'-webkit-transform',
|
|
'OTransform':'-o-transform',
|
|
'msTransform':'-ms-transform',
|
|
'MozTransform':'-moz-transform',
|
|
'transform':'transform'
|
|
};
|
|
|
|
// Add it to the body to get the computed style.
|
|
document.body.insertBefore(el, null);
|
|
|
|
for (var t in transforms) {
|
|
if (el.style[t] !== undefined) {
|
|
el.style[t] = "translate3d(1px,1px,1px)";
|
|
has3d = window.getComputedStyle(el).getPropertyValue(transforms[t]);
|
|
}
|
|
}
|
|
|
|
document.body.removeChild(el);
|
|
|
|
return (has3d !== undefined && has3d.length > 0 && has3d !== "none");
|
|
}
|
|
|
|
|
|
/**
|
|
* return browser preview for transforms.
|
|
* @private
|
|
* @param { string } translate3d - css transform propert
|
|
*/
|
|
function getTransforms(translate3d){
|
|
return {
|
|
'-webkit-transform': translate3d,
|
|
'-moz-transform': translate3d,
|
|
'-ms-transform':translate3d,
|
|
'transform': translate3d
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Adds a css3 transform property to the container class with or without animation depending on the animated param.
|
|
* @private
|
|
*/
|
|
function transformContainer(translate3d, animated){
|
|
// container.toggleClass('easing', animated);
|
|
var transformsObject = getTransforms(translate3d);
|
|
|
|
// container.css(getTransforms(translate3d));
|
|
for(var x in transformsObject){
|
|
container.style[x] = transformsObject[x];
|
|
}
|
|
}
|
|
|
|
function transformElement(translate3d,element){
|
|
// container.toggleClass('easing', animated);
|
|
var transformsObject = getTransforms(translate3d);
|
|
|
|
// container.css(getTransforms(translate3d));
|
|
for(var x in transformsObject){
|
|
element.style[x] = transformsObject[x];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* set the remove scrolling effect
|
|
* @private
|
|
* @param {number} top
|
|
*/
|
|
function silentScroll(top){
|
|
console.log("silentScroll");
|
|
|
|
if (options.css3) {
|
|
var translate3d = 'translate3d(0px, -' + top + 'px, 0px)';
|
|
transformContainer(translate3d, false);
|
|
}
|
|
else {
|
|
// container.css("top", -top);
|
|
container.style.top = -top+'px';
|
|
}
|
|
}
|
|
};
|
|
|
|
module.exports = linotype;
|
|
|
|
|
|
// If there is a window object, that at least has a document property,
|
|
// define linotype
|
|
if ( typeof window === "object" && typeof window.document === "object" ) {
|
|
window.linotype = linotype;
|
|
}
|
|
},{"./domhelper":3,"./slimscroll":5,"classie":11,"events":6,"util":10,"util-extend":13}],5:[function(require,module,exports){
|
|
/* jshint debug:true */
|
|
/*
|
|
* linotype
|
|
* https://github.com/typesettin/linotype
|
|
* @author yaw joseph etse
|
|
* Copyright (c) 2014 Typesettin. All rights reserved.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
var classie = require('classie'),
|
|
extend = require('util-extend'),
|
|
domhelper = require('./domhelper');
|
|
// events = require('events'),
|
|
// util = require('util');
|
|
|
|
/**
|
|
* creates slim scrollers.
|
|
* @author yaw joseph etse
|
|
* @module
|
|
*/
|
|
var slimscroll = function(options,elementsArray){
|
|
var defaults = {
|
|
idSelector: 'body',
|
|
width : 'auto',// width in pixels of the visible scroll area
|
|
height : '250px',// height in pixels of the visible scroll area
|
|
size : '7px',// width in pixels of the scrollbar and rail
|
|
color: '#000',// scrollbar color, accepts any hex/color value
|
|
position : 'right',// scrollbar position - left/right
|
|
distance : '1px',// distance in pixels between the side edge and the scrollbar
|
|
start : 'top',// default scroll position on load - top / bottom / $('selector')
|
|
opacity : 0.4,// sets scrollbar opacity
|
|
alwaysVisible : false,// enables always-on mode for the scrollbar
|
|
disableFadeOut : false,// check if we should hide the scrollbar when user is hovering over
|
|
railVisible : false,// sets visibility of the rail
|
|
railColor : '#333',// sets rail color
|
|
railOpacity : 0.2,// sets rail opacity
|
|
railDraggable : true,// whether we should use jQuery UI Draggable to enable bar dragging
|
|
railClass : 'slimScrollRail',// defautlt CSS class of the slimscroll rail
|
|
barClass : 'slimScrollBar',// defautlt CSS class of the slimscroll bar
|
|
wrapperClass : 'slimScrollDiv',// defautlt CSS class of the slimscroll wrapper
|
|
allowPageScroll : false,// check if mousewheel should scroll the window if we reach top/bottom
|
|
wheelStep : 20,// scroll amount applied to each mouse wheel step
|
|
touchScrollStep : 200,// scroll amount applied when user is using gestures
|
|
addedOriginalClass: 'originalScrollableElement',
|
|
borderRadius: '7px',// sets border radius
|
|
railBorderRadius : '7px'// sets border radius of the rail
|
|
},
|
|
o = extend( defaults,options ),
|
|
thisElements = (elementsArray) ? elementsArray : document.querySelectorAll(options.idSelector),
|
|
me,
|
|
rail,
|
|
bar,
|
|
barHeight,
|
|
minBarHeight = 30,
|
|
mousedownPageY,
|
|
mousedownT,
|
|
isDragg,
|
|
currentBar,
|
|
currentTouchDif,
|
|
releaseScroll,
|
|
isOverBar,
|
|
percentScroll,
|
|
queueHide,
|
|
lastScroll,
|
|
isOverPanel;
|
|
|
|
this.init = function(){
|
|
// do it for every element that matches selector
|
|
for(var x=0; x<thisElements.length;x++){
|
|
var touchDif,
|
|
barHeight,
|
|
divS = '<div></div>';
|
|
releaseScroll = false;
|
|
// used in event handlers and for better minification
|
|
me = thisElements[x];
|
|
classie.addClass(me,o.addedOriginalClass);
|
|
|
|
// ensure we are not binding it again
|
|
if( classie.hasClass(me.parentNode,o.wrapperClass) ){
|
|
// start from last bar position
|
|
var offset = me.scrollTop;
|
|
bar = me.parentNode.querSelector('.' + o.barClass),// find bar and rail,
|
|
rail = me.parentNode.querSelector('.' + o.railClass);
|
|
|
|
getBarHeight();
|
|
|
|
// check if we should scroll existing instance
|
|
if (typeof options==='object'){
|
|
// Pass height: auto to an existing slimscroll object to force a resize after contents have changed
|
|
if ( 'height' in options && options.height === 'auto' ) {
|
|
me.parentNode.style.height='auto';
|
|
me.style.height='auto';
|
|
var height = me.parentNode.parentNode.scrollHeight;
|
|
me.parent.style.height=height;
|
|
me.style.height=height;
|
|
}
|
|
|
|
if ('scrollTo' in options){
|
|
// jump to a static point
|
|
offset = parseInt(o.scrollTo,10);
|
|
}
|
|
else if ('scrollBy' in options){
|
|
// jump by value pixels
|
|
offset += parseInt(o.scrollBy,10);
|
|
}
|
|
else if ('destroy' in options){
|
|
// remove slimscroll elements
|
|
domhelper.removeElement(bar);
|
|
domhelper.removeElement(rail);
|
|
domhelper.unwrapElement(me);
|
|
return;
|
|
}
|
|
|
|
// scroll content by the given offset
|
|
console.log("add scrollContent");
|
|
// scrollContent(offset, false, true);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// optionally set height to the parent's height
|
|
o.height = (options.height === 'auto') ? me.parentNode.offsetHeight : options.height;
|
|
|
|
// wrap content
|
|
var wrapper = document.createElement("div");
|
|
classie.addClass(wrapper,o.wrapperClass);
|
|
wrapper.style.position= 'relative';
|
|
wrapper.style.overflow= 'hidden';
|
|
wrapper.style.width= o.width;
|
|
wrapper.style.height= o.height;
|
|
|
|
// update style for the div
|
|
me.style.overflow= 'hidden';
|
|
me.style.width= o.width;
|
|
me.style.height= o.height;
|
|
|
|
// create scrollbar rail
|
|
rail = document.createElement("div");
|
|
classie.addClass(rail,o.railClass);
|
|
rail.style.width= o.size;
|
|
rail.style.height= '100%';
|
|
rail.style.position= 'absolute';
|
|
rail.style.top= 0;
|
|
rail.style.display= (o.alwaysVisible && o.railVisible) ? 'block' : 'none';
|
|
rail.style['border-radius']= o.railBorderRadius;
|
|
rail.style.background= o.railColor;
|
|
rail.style.opacity= o.railOpacity;
|
|
rail.style.zIndex= 90;
|
|
|
|
// create scrollbar
|
|
bar = document.createElement("div");
|
|
classie.addClass(bar,o.barClass);
|
|
bar.style.background= o.color;
|
|
bar.style.width= o.size;
|
|
bar.style.position= 'absolute';
|
|
bar.style.top= 0;
|
|
bar.style.opacity= o.opacity;
|
|
bar.style.display= o.alwaysVisible ? 'block' : 'none';
|
|
bar.style['border-radius'] = o.borderRadius;
|
|
bar.style.BorderRadius= o.borderRadius;
|
|
bar.style.MozBorderRadius= o.borderRadius;
|
|
bar.style.WebkitBorderRadius= o.borderRadius;
|
|
bar.style.zIndex= 99;
|
|
|
|
// set position
|
|
if(o.position === 'right'){
|
|
rail.style.right = o.distance;
|
|
bar.style.right = o.distance;
|
|
}
|
|
else{
|
|
rail.style.left = o.distance;
|
|
bar.style.left = o.distance;
|
|
}
|
|
|
|
// wrap it
|
|
domhelper.elementWrap(me,wrapper);
|
|
|
|
// append to parent div
|
|
me.parentNode.appendChild(bar);
|
|
me.parentNode.appendChild(rail);
|
|
|
|
// set up initial height
|
|
getBarHeight();
|
|
|
|
// make it draggable and no longer dependent on the jqueryUI
|
|
bar.addEventListener("mousedown",mousedownEventHandler);
|
|
document.addEventListener("mouseup",mouseupEventHandler);
|
|
bar.addEventListener("selectstart",selectstartEventHandler);
|
|
bar.addEventListener("mouseover",mouseoverEventHandler);
|
|
bar.addEventListener("mouseleave",mouseleaveEventHandler);
|
|
bar.addEventListener('touchstart',scrollContainerTouchStartEventHandler);
|
|
|
|
rail.addEventListener("mouseover",railMouseOverEventHandler);
|
|
rail.addEventListener("mouseleave",railMouseLeaveEventHandler);
|
|
|
|
me.addEventListener("mouseover",scrollContainerMouseOverEventHandler);
|
|
me.addEventListener("mouseleave",scrollContainerMouseLeaveEventHandler);
|
|
me.addEventListener('DOMMouseScroll', mouseWheelEventHandler, false );
|
|
me.addEventListener('mousewheel', mouseWheelEventHandler, false );
|
|
}
|
|
|
|
// check start position
|
|
if (o.start === 'bottom'){
|
|
// scroll content to bottom
|
|
bar.style.top= me.offsetHeight - bar.offsetHeight;
|
|
scrollContent(0, true);
|
|
}
|
|
else if (o.start !== 'top'){
|
|
// assume jQuery selector
|
|
scrollContent( domhelper.getPosition(document.querSelector(o.start).top, null, true));
|
|
|
|
// make sure bar stays hidden
|
|
if (!o.alwaysVisible) {
|
|
domhelper.elementHideCss(bar);
|
|
}
|
|
}
|
|
document.addEventListener('touchmove',scrollContainerTouchMoveEventHandler);
|
|
}.bind(this);
|
|
|
|
function getBarHeight(){
|
|
if(!bar){
|
|
bar = currentBar;
|
|
}
|
|
// calculate scrollbar height and make sure it is not too small
|
|
barHeight = Math.max((me.offsetHeight / me.scrollHeight) * me.offsetHeight, minBarHeight);
|
|
bar.style.height= barHeight + 'px' ;
|
|
|
|
// hide scrollbar if content is not long enough
|
|
var display = (me.offsetHeight === barHeight) ? 'none' : 'block';
|
|
bar.style.display= display;
|
|
}
|
|
|
|
function scrollContent(y, isWheel, isJump,element,bar,isTouch){
|
|
releaseScroll = false;
|
|
var delta = y;
|
|
me = element;
|
|
bar = (bar)? bar : me.parentNode.querySelector('.'+o.barClass);
|
|
var maxTop = me.offsetHeight - bar.offsetHeight;
|
|
|
|
if (isWheel){
|
|
// move bar with mouse wheel
|
|
delta = parseInt(bar.style.
|
|
top,10) + y * parseInt(o.wheelStep,10) / 100 * bar.offsetHeight;
|
|
|
|
// move bar, make sure it doesn't go out
|
|
delta = Math.min(Math.max(delta, 0), maxTop);
|
|
|
|
// if scrolling down, make sure a fractional change to the
|
|
// scroll position isn't rounded away when the scrollbar's CSS is set
|
|
// this flooring of delta would happened automatically when
|
|
// bar.css is set below, but we floor here for clarity
|
|
delta = (y > 0) ? Math.ceil(delta) : Math.floor(delta);
|
|
|
|
// scroll the scrollbar
|
|
bar.style.top= delta + 'px';
|
|
}
|
|
else if(isTouch){
|
|
// calculate actual scroll amount
|
|
percentScroll = parseInt(bar.style.top,10) / (me.offsetHeight - bar.offsetHeight);
|
|
delta = percentScroll * (me.scrollHeight - me.offsetHeight);
|
|
|
|
// scroll the scrollbar
|
|
bar.style.top= delta + 'px';
|
|
}
|
|
|
|
// calculate actual scroll amount
|
|
percentScroll = parseInt(bar.style.top,10) / (me.offsetHeight - bar.offsetHeight);
|
|
delta = percentScroll * (me.scrollHeight - me.offsetHeight);
|
|
|
|
if (isJump){
|
|
delta = y;
|
|
var offsetTop = delta / me.scrollHeight * me.offsetHeight;
|
|
offsetTop = Math.min(Math.max(offsetTop, 0), maxTop);
|
|
bar.style.top= offsetTop + 'px';
|
|
}
|
|
|
|
// scroll content
|
|
me.scrollTop=delta;
|
|
|
|
// console.log("delta",delta,"~~delta",~~delta);
|
|
// fire scrolling event
|
|
// me.dispatchEvent(slimScrollEvent)
|
|
var newevent = document.createEvent("Event");
|
|
newevent.initEvent('slimscrolling',true,true,"blah");
|
|
me.dispatchEvent(newevent, ~~delta);
|
|
// me.trigger('slimscrolling', ~~delta);
|
|
|
|
// ensure bar is visible
|
|
showBar();
|
|
|
|
// trigger hide when scroll is stopped
|
|
hideBar();
|
|
}
|
|
function showBar(){
|
|
// recalculate bar height
|
|
getBarHeight();
|
|
clearTimeout(queueHide);
|
|
|
|
// when bar reached top or bottom
|
|
if (percentScroll === ~~percentScroll){
|
|
//release wheel
|
|
releaseScroll = o.allowPageScroll;
|
|
|
|
// publish approporiate event
|
|
if (lastScroll !== percentScroll){
|
|
var msg = (~~percentScroll === 0) ? 'top' : 'bottom';
|
|
var newevent = document.createEvent("Event");
|
|
newevent.initEvent('slimscroll',true,true);
|
|
me.dispatchEvent(newevent, msg);
|
|
}
|
|
}
|
|
else{
|
|
releaseScroll = false;
|
|
}
|
|
lastScroll = percentScroll;
|
|
|
|
// show only when required
|
|
if(barHeight >= me.offsetHeight) {
|
|
//allow window scroll
|
|
releaseScroll = true;
|
|
return;
|
|
}
|
|
bar.style.transition="opacity .5s";
|
|
bar.style.opacity=o.opacity;
|
|
if (o.railVisible) {
|
|
rail.style.transform="opacity .5s";
|
|
rail.style.opacity=1;
|
|
}
|
|
}
|
|
|
|
function hideBar(){
|
|
// only hide when options allow it
|
|
if (!o.alwaysVisible){
|
|
queueHide = setTimeout(function(){
|
|
if (!(o.disableFadeOut && isOverPanel) && !isOverBar && !isDragg){
|
|
bar.style.transition="opacity 1s";
|
|
bar.style.opacity=0;
|
|
rail.style.transition="opacity 1s";
|
|
rail.style.opacity=0;
|
|
}
|
|
}, 500);
|
|
}
|
|
}
|
|
|
|
function mouseWheelEventHandler(e){
|
|
// use mouse wheel only when mouse is over
|
|
if (!isOverPanel) { return; }
|
|
|
|
var delta = 0;
|
|
if (e.wheelDelta) {
|
|
delta = -e.wheelDelta/120;
|
|
}
|
|
if (e.detail) {
|
|
delta = e.detail / 3;
|
|
}
|
|
|
|
var target = e.target;
|
|
var parentWrapper = domhelper.getParentElement(target,o.wrapperClass);
|
|
console.log("parentWrapper",parentWrapper);
|
|
console.log("me",me);
|
|
if (parentWrapper /* && parentWrapper.isEqualNode(me.parentNode)*/ ){
|
|
// scroll content
|
|
scrollContent(delta, true,null,parentWrapper.querySelector('.'+o.addedOriginalClass));
|
|
}
|
|
else{
|
|
console.log("not the right parent node");
|
|
}
|
|
|
|
// stop window scroll
|
|
if (!releaseScroll) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
|
|
function mousedownEventHandler(e){
|
|
var eTarget = e.target;
|
|
currentBar = eTarget;
|
|
isDragg = true;
|
|
mousedownT = parseInt(eTarget.style.top,10);
|
|
mousedownPageY = e.pageY;
|
|
if(currentBar){
|
|
currentBar.addEventListener("mousemove",mousemoveEventHandler);
|
|
}
|
|
e.preventDefault();
|
|
return false;
|
|
}
|
|
|
|
function mousemoveEventHandler(e){
|
|
var currTop = mousedownT + e.pageY - mousedownPageY;
|
|
if(currentBar){
|
|
currentBar.style.top=currTop;
|
|
scrollContent(0, domhelper.getPosition(currentBar).top, false,me,currentBar);// scroll content
|
|
}
|
|
}
|
|
|
|
function mouseupEventHandler(e){
|
|
isDragg = false;
|
|
if(currentBar){
|
|
hideBar(currentBar);
|
|
currentBar.removeEventListener('mousemove',mousemoveEventHandler);
|
|
}
|
|
}
|
|
|
|
function mouseoverEventHandler(e){ isOverBar = true; }
|
|
|
|
function mouseleaveEventHandler(e){ isOverBar = false; }
|
|
|
|
function selectstartEventHandler(e){
|
|
// e.stopPropagation();
|
|
// e.preventDefault();
|
|
return false;
|
|
}
|
|
|
|
function railMouseOverEventHandler(e){ showBar(); }
|
|
|
|
function railMouseLeaveEventHandler(e){ hideBar(); }
|
|
|
|
function scrollContainerMouseOverEventHandler(e){
|
|
isOverPanel = true;
|
|
showBar(bar);
|
|
hideBar(bar);
|
|
}
|
|
|
|
function scrollContainerMouseLeaveEventHandler(e){
|
|
isOverPanel = true;
|
|
showBar(bar);
|
|
hideBar(bar);
|
|
}
|
|
|
|
function scrollContainerTouchStartEventHandler(e){
|
|
// console.log(e.target);
|
|
if (e.touches.length){
|
|
// record where touch started
|
|
currentTouchDif = e.touches[0].pageY;
|
|
}
|
|
}
|
|
|
|
function scrollContainerTouchMoveEventHandler(e){
|
|
// prevent scrolling the page if necessary
|
|
if(!releaseScroll){
|
|
e.preventDefault();
|
|
}
|
|
if(e.touches.length){
|
|
// see how far user swiped
|
|
var diff = (currentTouchDif - e.touches[0].pageY) / o.touchScrollStep;
|
|
// scroll content
|
|
scrollContent(diff, true,null,me,currentBar,true);
|
|
currentTouchDif = e.touches[0].pageY;
|
|
}
|
|
}
|
|
};
|
|
|
|
module.exports = slimscroll;
|
|
|
|
// If there is a window object, that at least has a document property,
|
|
// define linotype
|
|
if ( typeof window === "object" && typeof window.document === "object" ) {
|
|
window.slimscroll = slimscroll;
|
|
}
|
|
},{"./domhelper":3,"classie":11,"util-extend":13}],6:[function(require,module,exports){
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
// persons to whom the Software is furnished to do so, subject to the
|
|
// following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included
|
|
// in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
function EventEmitter() {
|
|
this._events = this._events || {};
|
|
this._maxListeners = this._maxListeners || undefined;
|
|
}
|
|
module.exports = EventEmitter;
|
|
|
|
// Backwards-compat with node 0.10.x
|
|
EventEmitter.EventEmitter = EventEmitter;
|
|
|
|
EventEmitter.prototype._events = undefined;
|
|
EventEmitter.prototype._maxListeners = undefined;
|
|
|
|
// By default EventEmitters will print a warning if more than 10 listeners are
|
|
// added to it. This is a useful default which helps finding memory leaks.
|
|
EventEmitter.defaultMaxListeners = 10;
|
|
|
|
// Obviously not all Emitters should be limited to 10. This function allows
|
|
// that to be increased. Set to zero for unlimited.
|
|
EventEmitter.prototype.setMaxListeners = function(n) {
|
|
if (!isNumber(n) || n < 0 || isNaN(n))
|
|
throw TypeError('n must be a positive number');
|
|
this._maxListeners = n;
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.emit = function(type) {
|
|
var er, handler, len, args, i, listeners;
|
|
|
|
if (!this._events)
|
|
this._events = {};
|
|
|
|
// If there is no 'error' event listener then throw.
|
|
if (type === 'error') {
|
|
if (!this._events.error ||
|
|
(isObject(this._events.error) && !this._events.error.length)) {
|
|
er = arguments[1];
|
|
if (er instanceof Error) {
|
|
throw er; // Unhandled 'error' event
|
|
} else {
|
|
throw TypeError('Uncaught, unspecified "error" event.');
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
handler = this._events[type];
|
|
|
|
if (isUndefined(handler))
|
|
return false;
|
|
|
|
if (isFunction(handler)) {
|
|
switch (arguments.length) {
|
|
// fast cases
|
|
case 1:
|
|
handler.call(this);
|
|
break;
|
|
case 2:
|
|
handler.call(this, arguments[1]);
|
|
break;
|
|
case 3:
|
|
handler.call(this, arguments[1], arguments[2]);
|
|
break;
|
|
// slower
|
|
default:
|
|
len = arguments.length;
|
|
args = new Array(len - 1);
|
|
for (i = 1; i < len; i++)
|
|
args[i - 1] = arguments[i];
|
|
handler.apply(this, args);
|
|
}
|
|
} else if (isObject(handler)) {
|
|
len = arguments.length;
|
|
args = new Array(len - 1);
|
|
for (i = 1; i < len; i++)
|
|
args[i - 1] = arguments[i];
|
|
|
|
listeners = handler.slice();
|
|
len = listeners.length;
|
|
for (i = 0; i < len; i++)
|
|
listeners[i].apply(this, args);
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
EventEmitter.prototype.addListener = function(type, listener) {
|
|
var m;
|
|
|
|
if (!isFunction(listener))
|
|
throw TypeError('listener must be a function');
|
|
|
|
if (!this._events)
|
|
this._events = {};
|
|
|
|
// To avoid recursion in the case that type === "newListener"! Before
|
|
// adding it to the listeners, first emit "newListener".
|
|
if (this._events.newListener)
|
|
this.emit('newListener', type,
|
|
isFunction(listener.listener) ?
|
|
listener.listener : listener);
|
|
|
|
if (!this._events[type])
|
|
// Optimize the case of one listener. Don't need the extra array object.
|
|
this._events[type] = listener;
|
|
else if (isObject(this._events[type]))
|
|
// If we've already got an array, just append.
|
|
this._events[type].push(listener);
|
|
else
|
|
// Adding the second element, need to change to array.
|
|
this._events[type] = [this._events[type], listener];
|
|
|
|
// Check for listener leak
|
|
if (isObject(this._events[type]) && !this._events[type].warned) {
|
|
var m;
|
|
if (!isUndefined(this._maxListeners)) {
|
|
m = this._maxListeners;
|
|
} else {
|
|
m = EventEmitter.defaultMaxListeners;
|
|
}
|
|
|
|
if (m && m > 0 && this._events[type].length > m) {
|
|
this._events[type].warned = true;
|
|
console.error('(node) warning: possible EventEmitter memory ' +
|
|
'leak detected. %d listeners added. ' +
|
|
'Use emitter.setMaxListeners() to increase limit.',
|
|
this._events[type].length);
|
|
console.trace();
|
|
}
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
|
|
|
|
EventEmitter.prototype.once = function(type, listener) {
|
|
if (!isFunction(listener))
|
|
throw TypeError('listener must be a function');
|
|
|
|
var fired = false;
|
|
|
|
function g() {
|
|
this.removeListener(type, g);
|
|
|
|
if (!fired) {
|
|
fired = true;
|
|
listener.apply(this, arguments);
|
|
}
|
|
}
|
|
|
|
g.listener = listener;
|
|
this.on(type, g);
|
|
|
|
return this;
|
|
};
|
|
|
|
// emits a 'removeListener' event iff the listener was removed
|
|
EventEmitter.prototype.removeListener = function(type, listener) {
|
|
var list, position, length, i;
|
|
|
|
if (!isFunction(listener))
|
|
throw TypeError('listener must be a function');
|
|
|
|
if (!this._events || !this._events[type])
|
|
return this;
|
|
|
|
list = this._events[type];
|
|
length = list.length;
|
|
position = -1;
|
|
|
|
if (list === listener ||
|
|
(isFunction(list.listener) && list.listener === listener)) {
|
|
delete this._events[type];
|
|
if (this._events.removeListener)
|
|
this.emit('removeListener', type, listener);
|
|
|
|
} else if (isObject(list)) {
|
|
for (i = length; i-- > 0;) {
|
|
if (list[i] === listener ||
|
|
(list[i].listener && list[i].listener === listener)) {
|
|
position = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (position < 0)
|
|
return this;
|
|
|
|
if (list.length === 1) {
|
|
list.length = 0;
|
|
delete this._events[type];
|
|
} else {
|
|
list.splice(position, 1);
|
|
}
|
|
|
|
if (this._events.removeListener)
|
|
this.emit('removeListener', type, listener);
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.removeAllListeners = function(type) {
|
|
var key, listeners;
|
|
|
|
if (!this._events)
|
|
return this;
|
|
|
|
// not listening for removeListener, no need to emit
|
|
if (!this._events.removeListener) {
|
|
if (arguments.length === 0)
|
|
this._events = {};
|
|
else if (this._events[type])
|
|
delete this._events[type];
|
|
return this;
|
|
}
|
|
|
|
// emit removeListener for all listeners on all events
|
|
if (arguments.length === 0) {
|
|
for (key in this._events) {
|
|
if (key === 'removeListener') continue;
|
|
this.removeAllListeners(key);
|
|
}
|
|
this.removeAllListeners('removeListener');
|
|
this._events = {};
|
|
return this;
|
|
}
|
|
|
|
listeners = this._events[type];
|
|
|
|
if (isFunction(listeners)) {
|
|
this.removeListener(type, listeners);
|
|
} else {
|
|
// LIFO order
|
|
while (listeners.length)
|
|
this.removeListener(type, listeners[listeners.length - 1]);
|
|
}
|
|
delete this._events[type];
|
|
|
|
return this;
|
|
};
|
|
|
|
EventEmitter.prototype.listeners = function(type) {
|
|
var ret;
|
|
if (!this._events || !this._events[type])
|
|
ret = [];
|
|
else if (isFunction(this._events[type]))
|
|
ret = [this._events[type]];
|
|
else
|
|
ret = this._events[type].slice();
|
|
return ret;
|
|
};
|
|
|
|
EventEmitter.listenerCount = function(emitter, type) {
|
|
var ret;
|
|
if (!emitter._events || !emitter._events[type])
|
|
ret = 0;
|
|
else if (isFunction(emitter._events[type]))
|
|
ret = 1;
|
|
else
|
|
ret = emitter._events[type].length;
|
|
return ret;
|
|
};
|
|
|
|
function isFunction(arg) {
|
|
return typeof arg === 'function';
|
|
}
|
|
|
|
function isNumber(arg) {
|
|
return typeof arg === 'number';
|
|
}
|
|
|
|
function isObject(arg) {
|
|
return typeof arg === 'object' && arg !== null;
|
|
}
|
|
|
|
function isUndefined(arg) {
|
|
return arg === void 0;
|
|
}
|
|
|
|
},{}],7:[function(require,module,exports){
|
|
if (typeof Object.create === 'function') {
|
|
// implementation from standard node.js 'util' module
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
ctor.super_ = superCtor
|
|
ctor.prototype = Object.create(superCtor.prototype, {
|
|
constructor: {
|
|
value: ctor,
|
|
enumerable: false,
|
|
writable: true,
|
|
configurable: true
|
|
}
|
|
});
|
|
};
|
|
} else {
|
|
// old school shim for old browsers
|
|
module.exports = function inherits(ctor, superCtor) {
|
|
ctor.super_ = superCtor
|
|
var TempCtor = function () {}
|
|
TempCtor.prototype = superCtor.prototype
|
|
ctor.prototype = new TempCtor()
|
|
ctor.prototype.constructor = ctor
|
|
}
|
|
}
|
|
|
|
},{}],8:[function(require,module,exports){
|
|
// shim for using process in browser
|
|
|
|
var process = module.exports = {};
|
|
|
|
process.nextTick = (function () {
|
|
var canSetImmediate = typeof window !== 'undefined'
|
|
&& window.setImmediate;
|
|
var canPost = typeof window !== 'undefined'
|
|
&& window.postMessage && window.addEventListener
|
|
;
|
|
|
|
if (canSetImmediate) {
|
|
return function (f) { return window.setImmediate(f) };
|
|
}
|
|
|
|
if (canPost) {
|
|
var queue = [];
|
|
window.addEventListener('message', function (ev) {
|
|
var source = ev.source;
|
|
if ((source === window || source === null) && ev.data === 'process-tick') {
|
|
ev.stopPropagation();
|
|
if (queue.length > 0) {
|
|
var fn = queue.shift();
|
|
fn();
|
|
}
|
|
}
|
|
}, true);
|
|
|
|
return function nextTick(fn) {
|
|
queue.push(fn);
|
|
window.postMessage('process-tick', '*');
|
|
};
|
|
}
|
|
|
|
return function nextTick(fn) {
|
|
setTimeout(fn, 0);
|
|
};
|
|
})();
|
|
|
|
process.title = 'browser';
|
|
process.browser = true;
|
|
process.env = {};
|
|
process.argv = [];
|
|
|
|
function noop() {}
|
|
|
|
process.on = noop;
|
|
process.addListener = noop;
|
|
process.once = noop;
|
|
process.off = noop;
|
|
process.removeListener = noop;
|
|
process.removeAllListeners = noop;
|
|
process.emit = noop;
|
|
|
|
process.binding = function (name) {
|
|
throw new Error('process.binding is not supported');
|
|
}
|
|
|
|
// TODO(shtylman)
|
|
process.cwd = function () { return '/' };
|
|
process.chdir = function (dir) {
|
|
throw new Error('process.chdir is not supported');
|
|
};
|
|
|
|
},{}],9:[function(require,module,exports){
|
|
module.exports = function isBuffer(arg) {
|
|
return arg && typeof arg === 'object'
|
|
&& typeof arg.copy === 'function'
|
|
&& typeof arg.fill === 'function'
|
|
&& typeof arg.readUInt8 === 'function';
|
|
}
|
|
},{}],10:[function(require,module,exports){
|
|
(function (process,global){
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
// persons to whom the Software is furnished to do so, subject to the
|
|
// following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included
|
|
// in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
var formatRegExp = /%[sdj%]/g;
|
|
exports.format = function(f) {
|
|
if (!isString(f)) {
|
|
var objects = [];
|
|
for (var i = 0; i < arguments.length; i++) {
|
|
objects.push(inspect(arguments[i]));
|
|
}
|
|
return objects.join(' ');
|
|
}
|
|
|
|
var i = 1;
|
|
var args = arguments;
|
|
var len = args.length;
|
|
var str = String(f).replace(formatRegExp, function(x) {
|
|
if (x === '%%') return '%';
|
|
if (i >= len) return x;
|
|
switch (x) {
|
|
case '%s': return String(args[i++]);
|
|
case '%d': return Number(args[i++]);
|
|
case '%j':
|
|
try {
|
|
return JSON.stringify(args[i++]);
|
|
} catch (_) {
|
|
return '[Circular]';
|
|
}
|
|
default:
|
|
return x;
|
|
}
|
|
});
|
|
for (var x = args[i]; i < len; x = args[++i]) {
|
|
if (isNull(x) || !isObject(x)) {
|
|
str += ' ' + x;
|
|
} else {
|
|
str += ' ' + inspect(x);
|
|
}
|
|
}
|
|
return str;
|
|
};
|
|
|
|
|
|
// Mark that a method should not be used.
|
|
// Returns a modified function which warns once by default.
|
|
// If --no-deprecation is set, then it is a no-op.
|
|
exports.deprecate = function(fn, msg) {
|
|
// Allow for deprecating things in the process of starting up.
|
|
if (isUndefined(global.process)) {
|
|
return function() {
|
|
return exports.deprecate(fn, msg).apply(this, arguments);
|
|
};
|
|
}
|
|
|
|
if (process.noDeprecation === true) {
|
|
return fn;
|
|
}
|
|
|
|
var warned = false;
|
|
function deprecated() {
|
|
if (!warned) {
|
|
if (process.throwDeprecation) {
|
|
throw new Error(msg);
|
|
} else if (process.traceDeprecation) {
|
|
console.trace(msg);
|
|
} else {
|
|
console.error(msg);
|
|
}
|
|
warned = true;
|
|
}
|
|
return fn.apply(this, arguments);
|
|
}
|
|
|
|
return deprecated;
|
|
};
|
|
|
|
|
|
var debugs = {};
|
|
var debugEnviron;
|
|
exports.debuglog = function(set) {
|
|
if (isUndefined(debugEnviron))
|
|
debugEnviron = process.env.NODE_DEBUG || '';
|
|
set = set.toUpperCase();
|
|
if (!debugs[set]) {
|
|
if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
|
|
var pid = process.pid;
|
|
debugs[set] = function() {
|
|
var msg = exports.format.apply(exports, arguments);
|
|
console.error('%s %d: %s', set, pid, msg);
|
|
};
|
|
} else {
|
|
debugs[set] = function() {};
|
|
}
|
|
}
|
|
return debugs[set];
|
|
};
|
|
|
|
|
|
/**
|
|
* Echos the value of a value. Trys to print the value out
|
|
* in the best way possible given the different types.
|
|
*
|
|
* @param {Object} obj The object to print out.
|
|
* @param {Object} opts Optional options object that alters the output.
|
|
*/
|
|
/* legacy: obj, showHidden, depth, colors*/
|
|
function inspect(obj, opts) {
|
|
// default options
|
|
var ctx = {
|
|
seen: [],
|
|
stylize: stylizeNoColor
|
|
};
|
|
// legacy...
|
|
if (arguments.length >= 3) ctx.depth = arguments[2];
|
|
if (arguments.length >= 4) ctx.colors = arguments[3];
|
|
if (isBoolean(opts)) {
|
|
// legacy...
|
|
ctx.showHidden = opts;
|
|
} else if (opts) {
|
|
// got an "options" object
|
|
exports._extend(ctx, opts);
|
|
}
|
|
// set default options
|
|
if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
|
|
if (isUndefined(ctx.depth)) ctx.depth = 2;
|
|
if (isUndefined(ctx.colors)) ctx.colors = false;
|
|
if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
|
|
if (ctx.colors) ctx.stylize = stylizeWithColor;
|
|
return formatValue(ctx, obj, ctx.depth);
|
|
}
|
|
exports.inspect = inspect;
|
|
|
|
|
|
// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
|
|
inspect.colors = {
|
|
'bold' : [1, 22],
|
|
'italic' : [3, 23],
|
|
'underline' : [4, 24],
|
|
'inverse' : [7, 27],
|
|
'white' : [37, 39],
|
|
'grey' : [90, 39],
|
|
'black' : [30, 39],
|
|
'blue' : [34, 39],
|
|
'cyan' : [36, 39],
|
|
'green' : [32, 39],
|
|
'magenta' : [35, 39],
|
|
'red' : [31, 39],
|
|
'yellow' : [33, 39]
|
|
};
|
|
|
|
// Don't use 'blue' not visible on cmd.exe
|
|
inspect.styles = {
|
|
'special': 'cyan',
|
|
'number': 'yellow',
|
|
'boolean': 'yellow',
|
|
'undefined': 'grey',
|
|
'null': 'bold',
|
|
'string': 'green',
|
|
'date': 'magenta',
|
|
// "name": intentionally not styling
|
|
'regexp': 'red'
|
|
};
|
|
|
|
|
|
function stylizeWithColor(str, styleType) {
|
|
var style = inspect.styles[styleType];
|
|
|
|
if (style) {
|
|
return '\u001b[' + inspect.colors[style][0] + 'm' + str +
|
|
'\u001b[' + inspect.colors[style][1] + 'm';
|
|
} else {
|
|
return str;
|
|
}
|
|
}
|
|
|
|
|
|
function stylizeNoColor(str, styleType) {
|
|
return str;
|
|
}
|
|
|
|
|
|
function arrayToHash(array) {
|
|
var hash = {};
|
|
|
|
array.forEach(function(val, idx) {
|
|
hash[val] = true;
|
|
});
|
|
|
|
return hash;
|
|
}
|
|
|
|
|
|
function formatValue(ctx, value, recurseTimes) {
|
|
// Provide a hook for user-specified inspect functions.
|
|
// Check that value is an object with an inspect function on it
|
|
if (ctx.customInspect &&
|
|
value &&
|
|
isFunction(value.inspect) &&
|
|
// Filter out the util module, it's inspect function is special
|
|
value.inspect !== exports.inspect &&
|
|
// Also filter out any prototype objects using the circular check.
|
|
!(value.constructor && value.constructor.prototype === value)) {
|
|
var ret = value.inspect(recurseTimes, ctx);
|
|
if (!isString(ret)) {
|
|
ret = formatValue(ctx, ret, recurseTimes);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// Primitive types cannot have properties
|
|
var primitive = formatPrimitive(ctx, value);
|
|
if (primitive) {
|
|
return primitive;
|
|
}
|
|
|
|
// Look up the keys of the object.
|
|
var keys = Object.keys(value);
|
|
var visibleKeys = arrayToHash(keys);
|
|
|
|
if (ctx.showHidden) {
|
|
keys = Object.getOwnPropertyNames(value);
|
|
}
|
|
|
|
// IE doesn't make error fields non-enumerable
|
|
// http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
|
|
if (isError(value)
|
|
&& (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
|
|
return formatError(value);
|
|
}
|
|
|
|
// Some type of object without properties can be shortcutted.
|
|
if (keys.length === 0) {
|
|
if (isFunction(value)) {
|
|
var name = value.name ? ': ' + value.name : '';
|
|
return ctx.stylize('[Function' + name + ']', 'special');
|
|
}
|
|
if (isRegExp(value)) {
|
|
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
|
}
|
|
if (isDate(value)) {
|
|
return ctx.stylize(Date.prototype.toString.call(value), 'date');
|
|
}
|
|
if (isError(value)) {
|
|
return formatError(value);
|
|
}
|
|
}
|
|
|
|
var base = '', array = false, braces = ['{', '}'];
|
|
|
|
// Make Array say that they are Array
|
|
if (isArray(value)) {
|
|
array = true;
|
|
braces = ['[', ']'];
|
|
}
|
|
|
|
// Make functions say that they are functions
|
|
if (isFunction(value)) {
|
|
var n = value.name ? ': ' + value.name : '';
|
|
base = ' [Function' + n + ']';
|
|
}
|
|
|
|
// Make RegExps say that they are RegExps
|
|
if (isRegExp(value)) {
|
|
base = ' ' + RegExp.prototype.toString.call(value);
|
|
}
|
|
|
|
// Make dates with properties first say the date
|
|
if (isDate(value)) {
|
|
base = ' ' + Date.prototype.toUTCString.call(value);
|
|
}
|
|
|
|
// Make error with message first say the error
|
|
if (isError(value)) {
|
|
base = ' ' + formatError(value);
|
|
}
|
|
|
|
if (keys.length === 0 && (!array || value.length == 0)) {
|
|
return braces[0] + base + braces[1];
|
|
}
|
|
|
|
if (recurseTimes < 0) {
|
|
if (isRegExp(value)) {
|
|
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
|
} else {
|
|
return ctx.stylize('[Object]', 'special');
|
|
}
|
|
}
|
|
|
|
ctx.seen.push(value);
|
|
|
|
var output;
|
|
if (array) {
|
|
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
|
|
} else {
|
|
output = keys.map(function(key) {
|
|
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
|
|
});
|
|
}
|
|
|
|
ctx.seen.pop();
|
|
|
|
return reduceToSingleString(output, base, braces);
|
|
}
|
|
|
|
|
|
function formatPrimitive(ctx, value) {
|
|
if (isUndefined(value))
|
|
return ctx.stylize('undefined', 'undefined');
|
|
if (isString(value)) {
|
|
var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
|
|
.replace(/'/g, "\\'")
|
|
.replace(/\\"/g, '"') + '\'';
|
|
return ctx.stylize(simple, 'string');
|
|
}
|
|
if (isNumber(value))
|
|
return ctx.stylize('' + value, 'number');
|
|
if (isBoolean(value))
|
|
return ctx.stylize('' + value, 'boolean');
|
|
// For some reason typeof null is "object", so special case here.
|
|
if (isNull(value))
|
|
return ctx.stylize('null', 'null');
|
|
}
|
|
|
|
|
|
function formatError(value) {
|
|
return '[' + Error.prototype.toString.call(value) + ']';
|
|
}
|
|
|
|
|
|
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
|
|
var output = [];
|
|
for (var i = 0, l = value.length; i < l; ++i) {
|
|
if (hasOwnProperty(value, String(i))) {
|
|
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
|
String(i), true));
|
|
} else {
|
|
output.push('');
|
|
}
|
|
}
|
|
keys.forEach(function(key) {
|
|
if (!key.match(/^\d+$/)) {
|
|
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
|
key, true));
|
|
}
|
|
});
|
|
return output;
|
|
}
|
|
|
|
|
|
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
|
|
var name, str, desc;
|
|
desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
|
|
if (desc.get) {
|
|
if (desc.set) {
|
|
str = ctx.stylize('[Getter/Setter]', 'special');
|
|
} else {
|
|
str = ctx.stylize('[Getter]', 'special');
|
|
}
|
|
} else {
|
|
if (desc.set) {
|
|
str = ctx.stylize('[Setter]', 'special');
|
|
}
|
|
}
|
|
if (!hasOwnProperty(visibleKeys, key)) {
|
|
name = '[' + key + ']';
|
|
}
|
|
if (!str) {
|
|
if (ctx.seen.indexOf(desc.value) < 0) {
|
|
if (isNull(recurseTimes)) {
|
|
str = formatValue(ctx, desc.value, null);
|
|
} else {
|
|
str = formatValue(ctx, desc.value, recurseTimes - 1);
|
|
}
|
|
if (str.indexOf('\n') > -1) {
|
|
if (array) {
|
|
str = str.split('\n').map(function(line) {
|
|
return ' ' + line;
|
|
}).join('\n').substr(2);
|
|
} else {
|
|
str = '\n' + str.split('\n').map(function(line) {
|
|
return ' ' + line;
|
|
}).join('\n');
|
|
}
|
|
}
|
|
} else {
|
|
str = ctx.stylize('[Circular]', 'special');
|
|
}
|
|
}
|
|
if (isUndefined(name)) {
|
|
if (array && key.match(/^\d+$/)) {
|
|
return str;
|
|
}
|
|
name = JSON.stringify('' + key);
|
|
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
|
|
name = name.substr(1, name.length - 2);
|
|
name = ctx.stylize(name, 'name');
|
|
} else {
|
|
name = name.replace(/'/g, "\\'")
|
|
.replace(/\\"/g, '"')
|
|
.replace(/(^"|"$)/g, "'");
|
|
name = ctx.stylize(name, 'string');
|
|
}
|
|
}
|
|
|
|
return name + ': ' + str;
|
|
}
|
|
|
|
|
|
function reduceToSingleString(output, base, braces) {
|
|
var numLinesEst = 0;
|
|
var length = output.reduce(function(prev, cur) {
|
|
numLinesEst++;
|
|
if (cur.indexOf('\n') >= 0) numLinesEst++;
|
|
return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
|
|
}, 0);
|
|
|
|
if (length > 60) {
|
|
return braces[0] +
|
|
(base === '' ? '' : base + '\n ') +
|
|
' ' +
|
|
output.join(',\n ') +
|
|
' ' +
|
|
braces[1];
|
|
}
|
|
|
|
return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
|
|
}
|
|
|
|
|
|
// NOTE: These type checking functions intentionally don't use `instanceof`
|
|
// because it is fragile and can be easily faked with `Object.create()`.
|
|
function isArray(ar) {
|
|
return Array.isArray(ar);
|
|
}
|
|
exports.isArray = isArray;
|
|
|
|
function isBoolean(arg) {
|
|
return typeof arg === 'boolean';
|
|
}
|
|
exports.isBoolean = isBoolean;
|
|
|
|
function isNull(arg) {
|
|
return arg === null;
|
|
}
|
|
exports.isNull = isNull;
|
|
|
|
function isNullOrUndefined(arg) {
|
|
return arg == null;
|
|
}
|
|
exports.isNullOrUndefined = isNullOrUndefined;
|
|
|
|
function isNumber(arg) {
|
|
return typeof arg === 'number';
|
|
}
|
|
exports.isNumber = isNumber;
|
|
|
|
function isString(arg) {
|
|
return typeof arg === 'string';
|
|
}
|
|
exports.isString = isString;
|
|
|
|
function isSymbol(arg) {
|
|
return typeof arg === 'symbol';
|
|
}
|
|
exports.isSymbol = isSymbol;
|
|
|
|
function isUndefined(arg) {
|
|
return arg === void 0;
|
|
}
|
|
exports.isUndefined = isUndefined;
|
|
|
|
function isRegExp(re) {
|
|
return isObject(re) && objectToString(re) === '[object RegExp]';
|
|
}
|
|
exports.isRegExp = isRegExp;
|
|
|
|
function isObject(arg) {
|
|
return typeof arg === 'object' && arg !== null;
|
|
}
|
|
exports.isObject = isObject;
|
|
|
|
function isDate(d) {
|
|
return isObject(d) && objectToString(d) === '[object Date]';
|
|
}
|
|
exports.isDate = isDate;
|
|
|
|
function isError(e) {
|
|
return isObject(e) &&
|
|
(objectToString(e) === '[object Error]' || e instanceof Error);
|
|
}
|
|
exports.isError = isError;
|
|
|
|
function isFunction(arg) {
|
|
return typeof arg === 'function';
|
|
}
|
|
exports.isFunction = isFunction;
|
|
|
|
function isPrimitive(arg) {
|
|
return arg === null ||
|
|
typeof arg === 'boolean' ||
|
|
typeof arg === 'number' ||
|
|
typeof arg === 'string' ||
|
|
typeof arg === 'symbol' || // ES6 symbol
|
|
typeof arg === 'undefined';
|
|
}
|
|
exports.isPrimitive = isPrimitive;
|
|
|
|
exports.isBuffer = require('./support/isBuffer');
|
|
|
|
function objectToString(o) {
|
|
return Object.prototype.toString.call(o);
|
|
}
|
|
|
|
|
|
function pad(n) {
|
|
return n < 10 ? '0' + n.toString(10) : n.toString(10);
|
|
}
|
|
|
|
|
|
var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
|
|
'Oct', 'Nov', 'Dec'];
|
|
|
|
// 26 Feb 16:19:34
|
|
function timestamp() {
|
|
var d = new Date();
|
|
var time = [pad(d.getHours()),
|
|
pad(d.getMinutes()),
|
|
pad(d.getSeconds())].join(':');
|
|
return [d.getDate(), months[d.getMonth()], time].join(' ');
|
|
}
|
|
|
|
|
|
// log is just a thin wrapper to console.log that prepends a timestamp
|
|
exports.log = function() {
|
|
console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
|
|
};
|
|
|
|
|
|
/**
|
|
* Inherit the prototype methods from one constructor into another.
|
|
*
|
|
* The Function.prototype.inherits from lang.js rewritten as a standalone
|
|
* function (not on Function.prototype). NOTE: If this file is to be loaded
|
|
* during bootstrapping this function needs to be rewritten using some native
|
|
* functions as prototype setup using normal JavaScript does not work as
|
|
* expected during bootstrapping (see mirror.js in r114903).
|
|
*
|
|
* @param {function} ctor Constructor function which needs to inherit the
|
|
* prototype.
|
|
* @param {function} superCtor Constructor function to inherit prototype from.
|
|
*/
|
|
exports.inherits = require('inherits');
|
|
|
|
exports._extend = function(origin, add) {
|
|
// Don't do anything if add isn't an object
|
|
if (!add || !isObject(add)) return origin;
|
|
|
|
var keys = Object.keys(add);
|
|
var i = keys.length;
|
|
while (i--) {
|
|
origin[keys[i]] = add[keys[i]];
|
|
}
|
|
return origin;
|
|
};
|
|
|
|
function hasOwnProperty(obj, prop) {
|
|
return Object.prototype.hasOwnProperty.call(obj, prop);
|
|
}
|
|
|
|
}).call(this,require("FWaASH"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
|
},{"./support/isBuffer":9,"FWaASH":8,"inherits":7}],11:[function(require,module,exports){
|
|
/*
|
|
* classie
|
|
* http://github.amexpub.com/modules/classie
|
|
*
|
|
* Copyright (c) 2013 AmexPub. All rights reserved.
|
|
*/
|
|
|
|
module.exports = require('./lib/classie');
|
|
|
|
},{"./lib/classie":12}],12:[function(require,module,exports){
|
|
/*!
|
|
* classie - class helper functions
|
|
* from bonzo https://github.com/ded/bonzo
|
|
*
|
|
* classie.has( elem, 'my-class' ) -> true/false
|
|
* classie.add( elem, 'my-new-class' )
|
|
* classie.remove( elem, 'my-unwanted-class' )
|
|
* classie.toggle( elem, 'my-class' )
|
|
*/
|
|
|
|
/*jshint browser: true, strict: true, undef: true */
|
|
/*global define: false */
|
|
'use strict';
|
|
|
|
// class helper functions from bonzo https://github.com/ded/bonzo
|
|
|
|
function classReg( className ) {
|
|
return new RegExp("(^|\\s+)" + className + "(\\s+|$)");
|
|
}
|
|
|
|
// classList support for class management
|
|
// altho to be fair, the api sucks because it won't accept multiple classes at once
|
|
var hasClass, addClass, removeClass;
|
|
|
|
if (typeof document === "object" && 'classList' in document.documentElement ) {
|
|
hasClass = function( elem, c ) {
|
|
return elem.classList.contains( c );
|
|
};
|
|
addClass = function( elem, c ) {
|
|
elem.classList.add( c );
|
|
};
|
|
removeClass = function( elem, c ) {
|
|
elem.classList.remove( c );
|
|
};
|
|
}
|
|
else {
|
|
hasClass = function( elem, c ) {
|
|
return classReg( c ).test( elem.className );
|
|
};
|
|
addClass = function( elem, c ) {
|
|
if ( !hasClass( elem, c ) ) {
|
|
elem.className = elem.className + ' ' + c;
|
|
}
|
|
};
|
|
removeClass = function( elem, c ) {
|
|
elem.className = elem.className.replace( classReg( c ), ' ' );
|
|
};
|
|
}
|
|
|
|
function toggleClass( elem, c ) {
|
|
var fn = hasClass( elem, c ) ? removeClass : addClass;
|
|
fn( elem, c );
|
|
}
|
|
|
|
var classie = {
|
|
// full names
|
|
hasClass: hasClass,
|
|
addClass: addClass,
|
|
removeClass: removeClass,
|
|
toggleClass: toggleClass,
|
|
// short names
|
|
has: hasClass,
|
|
add: addClass,
|
|
remove: removeClass,
|
|
toggle: toggleClass
|
|
};
|
|
|
|
// transport
|
|
|
|
if ( typeof module === "object" && module && typeof module.exports === "object" ) {
|
|
// commonjs / browserify
|
|
module.exports = classie;
|
|
} else {
|
|
// AMD
|
|
define(classie);
|
|
}
|
|
|
|
// If there is a window object, that at least has a document property,
|
|
// define classie
|
|
if ( typeof window === "object" && typeof window.document === "object" ) {
|
|
window.classie = classie;
|
|
}
|
|
},{}],13:[function(require,module,exports){
|
|
// Copyright Joyent, Inc. and other Node contributors.
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
// copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to permit
|
|
// persons to whom the Software is furnished to do so, subject to the
|
|
// following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included
|
|
// in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
|
|
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
|
|
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
// USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
module.exports = extend;
|
|
function extend(origin, add) {
|
|
// Don't do anything if add isn't an object
|
|
if (!add || typeof add !== 'object') return origin;
|
|
|
|
var keys = Object.keys(add);
|
|
var i = keys.length;
|
|
while (i--) {
|
|
origin[keys[i]] = add[keys[i]];
|
|
}
|
|
return origin;
|
|
}
|
|
|
|
},{}]},{},[1]) |