File "debug.addIndicators.min.js"
Full Path: /home/cananyalcin/public_html/assets/js/vendor/debug.addIndicators.min.js
File size: 28.67 KB
MIME-type: text/plain
Charset: utf-8
/*!
* @file Debug Extension for ScrollMagic.
*/
/**
* This plugin was formerly known as the ScrollMagic debug extension.
*
* It enables you to add visual indicators to your page, to be able to see exactly when a scene is triggered.
*
* To have access to this extension, please include `plugins/debug.addIndicators.js`.
* @mixin debug.addIndicators
*/
(function (root, factory) {
if (typeof define === 'function' && define.amd) {
// AMD. Register as an anonymous module.
define(['ScrollMagic'], factory);
} else if (typeof exports === 'object') {
// CommonJS
factory(require('scrollmagic'));
} else {
// no browser global export needed, just execute
factory(root.ScrollMagic || (root.jQuery && root.jQuery.ScrollMagic));
}
}(this, function(ScrollMagic) {
"use strict";
var NAMESPACE = "debug.addIndicators";
// (BUILD) - REMOVE IN MINIFY - START
var
console = window.console || {},
err = Function.prototype.bind.call(console.error || console.log || function() {}, console);
if (!ScrollMagic) {
err("(" + NAMESPACE + ") -> ERROR: The ScrollMagic main module could not be found. Please make sure it's loaded before this plugin or use an asynchronous loader like requirejs.");
}
// (BUILD) - REMOVE IN MINIFY - END
// plugin settings
var
FONT_SIZE = "0.85em",
ZINDEX = "9999",
EDGE_OFFSET = 15; // minimum edge distance, added to indentation
// overall vars
var
_util = ScrollMagic._util,
_autoindex = 0;
ScrollMagic.Scene.extend(function () {
var
Scene = this,
_indicator;
// (BUILD) - REMOVE IN MINIFY - START
var log = function () {
if (Scene._log) { // not available, when main source minified
Array.prototype.splice.call(arguments, 1, 0, "(" + NAMESPACE + ")", "->");
Scene._log.apply(this, arguments);
}
};
// (BUILD) - REMOVE IN MINIFY - END
/**
* Add visual indicators for a ScrollMagic.Scene.
* @memberof! debug.addIndicators#
*
* @example
* // add basic indicators
* scene.addIndicators()
*
* // passing options
* scene.addIndicators({name: "pin scene", colorEnd: "#FFFFFF"});
*
* @param {object} [options] - An object containing one or more options for the indicators.
* @param {(string|object)} [options.parent] - A selector, DOM Object or a jQuery object that the indicators should be added to.
If undefined, the controller's container will be used.
* @param {number} [options.name=""] - This string will be displayed at the start and end indicators of the scene for identification purposes. If no name is supplied an automatic index will be used.
* @param {number} [options.indent=0] - Additional position offset for the indicators (useful, when having multiple scenes starting at the same position).
* @param {string} [options.colorStart=green] - CSS color definition for the start indicator.
* @param {string} [options.colorEnd=red] - CSS color definition for the end indicator.
* @param {string} [options.colorTrigger=blue] - CSS color definition for the trigger indicator.
*/
Scene.addIndicators = function(options) {
if (!_indicator) {
var
DEFAULT_OPTIONS = {
name: "",
indent: 0,
parent: undefined,
colorStart: "green",
colorEnd: "red",
colorTrigger: "blue",
};
options = _util.extend({}, DEFAULT_OPTIONS, options);
_autoindex++;
_indicator = new Indicator(Scene, options);
Scene.on("add.plugin_addIndicators", _indicator.add);
Scene.on("remove.plugin_addIndicators", _indicator.remove);
Scene.on("destroy.plugin_addIndicators", Scene.removeIndicators);
// it the scene already has a controller we can start right away.
if (Scene.controller()) {
_indicator.add();
}
}
return Scene;
};
/**
* Removes visual indicators from a ScrollMagic.Scene.
* @memberof! debug.addIndicators#
*
* @example
* // remove previously added indicators
* scene.removeIndicators()
*
*/
Scene.removeIndicators = function() {
if (_indicator) {
_indicator.remove();
this.off("*.plugin_addIndicators");
_indicator = undefined;
}
return Scene;
};
});
/*
* ----------------------------------------------------------------
* Extension for controller to store and update related indicators
* ----------------------------------------------------------------
*/
// add option to globally auto-add indicators to scenes
/**
* Every ScrollMagic.Controller instance now accepts an additional option.
* See {@link ScrollMagic.Controller} for a complete list of the standard options.
* @memberof! debug.addIndicators#
* @method new ScrollMagic.Controller(options)
* @example
* // make a controller and add indicators to all scenes attached
* var controller = new ScrollMagic.Controller({addIndicators: true});
* // this scene will automatically have indicators added to it
* new ScrollMagic.Scene()
* .addTo(controller);
*
* @param {object} [options] - Options for the Controller.
* @param {boolean} [options.addIndicators=false] - If set to `true` every scene that is added to the controller will automatically get indicators added to it.
*/
ScrollMagic.Controller.addOption("addIndicators", false);
// extend Controller
ScrollMagic.Controller.extend(function () {
var
Controller = this,
_info = Controller.info(),
_container = _info.container,
_isDocument = _info.isDocument,
_vertical = _info.vertical,
_indicators = { // container for all indicators and methods
groups: []
};
// (BUILD) - REMOVE IN MINIFY - START
var log = function () {
if (Controller._log) { // not available, when main source minified
Array.prototype.splice.call(arguments, 1, 0, "(" + NAMESPACE + ")", "->");
Controller._log.apply(this, arguments);
}
};
if (Controller._indicators) {
log(2, "WARNING: Scene already has a property '_indicators', which will be overwritten by plugin.");
}
// (BUILD) - REMOVE IN MINIFY - END
// add indicators container
this._indicators = _indicators;
/*
needed updates:
+++++++++++++++
start/end position on scene shift (handled in Indicator class)
trigger parameters on triggerHook value change (handled in Indicator class)
bounds position on container scroll or resize (to keep alignment to bottom/right)
trigger position on container resize, window resize (if container isn't document) and window scroll (if container isn't document)
*/
// event handler for when associated bounds markers need to be repositioned
var handleBoundsPositionChange = function () {
_indicators.updateBoundsPositions();
};
// event handler for when associated trigger groups need to be repositioned
var handleTriggerPositionChange = function () {
_indicators.updateTriggerGroupPositions();
};
_container.addEventListener("resize", handleTriggerPositionChange);
if (!_isDocument) {
window.addEventListener("resize", handleTriggerPositionChange);
window.addEventListener("scroll", handleTriggerPositionChange);
}
// update all related bounds containers
_container.addEventListener("resize", handleBoundsPositionChange);
_container.addEventListener("scroll", handleBoundsPositionChange);
// updates the position of the bounds container to aligned to the right for vertical containers and to the bottom for horizontal
this._indicators.updateBoundsPositions = function (specificIndicator) {
var // constant for all bounds
groups = specificIndicator ?
[_util.extend({}, specificIndicator.triggerGroup, {members: [specificIndicator]})]: // create a group with only one element
_indicators.groups, // use all
g = groups.length,
css = {},
paramPos = _vertical ? "left" : "top",
paramDimension = _vertical ? "width" : "height",
edge = _vertical ?
_util.get.scrollLeft(_container) + _util.get.width(_container) - EDGE_OFFSET:
_util.get.scrollTop(_container) + _util.get.height(_container) - EDGE_OFFSET,
b, triggerSize, group;
while (g--) { // group loop
group = groups[g];
b = group.members.length;
triggerSize = _util.get[paramDimension](group.element.firstChild);
while (b--) { // indicators loop
css[paramPos] = edge - triggerSize;
_util.css(group.members[b].bounds, css);
}
}
};
// updates the positions of all trigger groups attached to a controller or a specific one, if provided
this._indicators.updateTriggerGroupPositions = function (specificGroup) {
var // constant vars
groups = specificGroup ? [specificGroup] : _indicators.groups,
i = groups.length,
container = _isDocument ? document.body : _container,
containerOffset = _isDocument ? {top: 0, left: 0} : _util.get.offset(container, true),
edge = _vertical ?
_util.get.width(_container) - EDGE_OFFSET :
_util.get.height(_container) - EDGE_OFFSET,
paramDimension = _vertical ? "width" : "height",
paramTransform = _vertical ? "Y" : "X";
var // changing vars
group,
elem,
pos,
elemSize,
transform;
while (i--) {
group = groups[i];
elem = group.element;
pos = group.triggerHook * Controller.info("size");
elemSize = _util.get[paramDimension](elem.firstChild.firstChild);
transform = pos > elemSize ? "translate" + paramTransform + "(-100%)" : "";
_util.css(elem, {
top: containerOffset.top + (_vertical ? pos : edge - group.members[0].options.indent),
left: containerOffset.left + (_vertical ? edge - group.members[0].options.indent : pos)
});
_util.css(elem.firstChild.firstChild, {
"-ms-transform" : transform,
"-webkit-transform" : transform,
"transform" : transform
});
}
};
// updates the label for the group to contain the name, if it only has one member
this._indicators.updateTriggerGroupLabel = function (group) {
var
text = "trigger" + (group.members.length > 1 ? "" : " " + group.members[0].options.name),
elem = group.element.firstChild.firstChild,
doUpdate = elem.textContent !== text;
if (doUpdate) {
elem.textContent = text;
if (_vertical) { // bounds position is dependent on text length, so update
_indicators.updateBoundsPositions();
}
}
};
// add indicators if global option is set
this.addScene = function (newScene) {
if (this._options.addIndicators && newScene instanceof ScrollMagic.Scene && newScene.controller() === Controller) {
newScene.addIndicators();
}
// call original destroy method
this.$super.addScene.apply(this, arguments);
};
// remove all previously set listeners on destroy
this.destroy = function () {
_container.removeEventListener("resize", handleTriggerPositionChange);
if (!_isDocument) {
window.removeEventListener("resize", handleTriggerPositionChange);
window.removeEventListener("scroll", handleTriggerPositionChange);
}
_container.removeEventListener("resize", handleBoundsPositionChange);
_container.removeEventListener("scroll", handleBoundsPositionChange);
// call original destroy method
this.$super.destroy.apply(this, arguments);
};
return Controller;
});
/*
* ----------------------------------------------------------------
* Internal class for the construction of Indicators
* ----------------------------------------------------------------
*/
var Indicator = function (Scene, options) {
var
Indicator = this,
_elemBounds = TPL.bounds(),
_elemStart = TPL.start(options.colorStart),
_elemEnd = TPL.end(options.colorEnd),
_boundsContainer = options.parent && _util.get.elements(options.parent)[0],
_vertical,
_ctrl;
// (BUILD) - REMOVE IN MINIFY - START
var log = function () {
if (Scene._log) { // not available, when main source minified
Array.prototype.splice.call(arguments, 1, 0, "(" + NAMESPACE + ")", "->");
Scene._log.apply(this, arguments);
}
};
// (BUILD) - REMOVE IN MINIFY - END
options.name = options.name || _autoindex;
// prepare bounds elements
_elemStart.firstChild.textContent += " " + options.name;
_elemEnd.textContent += " " + options.name;
_elemBounds.appendChild(_elemStart);
_elemBounds.appendChild(_elemEnd);
// set public variables
Indicator.options = options;
Indicator.bounds = _elemBounds;
// will be set later
Indicator.triggerGroup = undefined;
// add indicators to DOM
this.add = function () {
_ctrl = Scene.controller();
_vertical = _ctrl.info("vertical");
var isDocument = _ctrl.info("isDocument");
if (!_boundsContainer) {
// no parent supplied or doesnt exist
_boundsContainer = isDocument ? document.body : _ctrl.info("container"); // check if window/document (then use body)
}
if (!isDocument && _util.css(_boundsContainer, "position") === 'static') {
// position mode needed for correct positioning of indicators
_util.css(_boundsContainer, {position: "relative"});
}
// add listeners for updates
Scene.on("change.plugin_addIndicators", handleTriggerParamsChange);
Scene.on("shift.plugin_addIndicators", handleBoundsParamsChange);
// updates trigger & bounds (will add elements if needed)
updateTriggerGroup();
updateBounds();
setTimeout(function () { // do after all execution is finished otherwise sometimes size calculations are off
_ctrl._indicators.updateBoundsPositions(Indicator);
}, 0);
log(3, "added indicators");
};
// remove indicators from DOM
this.remove = function () {
if (Indicator.triggerGroup) { // if not set there's nothing to remove
Scene.off("change.plugin_addIndicators", handleTriggerParamsChange);
Scene.off("shift.plugin_addIndicators", handleBoundsParamsChange);
if (Indicator.triggerGroup.members.length > 1) {
// just remove from memberlist of old group
var group = Indicator.triggerGroup;
group.members.splice(group.members.indexOf(Indicator), 1);
_ctrl._indicators.updateTriggerGroupLabel(group);
_ctrl._indicators.updateTriggerGroupPositions(group);
Indicator.triggerGroup = undefined;
} else {
// remove complete group
removeTriggerGroup();
}
removeBounds();
log(3, "removed indicators");
}
};
/*
* ----------------------------------------------------------------
* internal Event Handlers
* ----------------------------------------------------------------
*/
// event handler for when bounds params change
var handleBoundsParamsChange = function () {
updateBounds();
};
// event handler for when trigger params change
var handleTriggerParamsChange = function (e) {
if (e.what === "triggerHook") {
updateTriggerGroup();
}
};
/*
* ----------------------------------------------------------------
* Bounds (start / stop) management
* ----------------------------------------------------------------
*/
// adds an new bounds elements to the array and to the DOM
var addBounds = function () {
var v = _ctrl.info("vertical");
// apply stuff we didn't know before...
_util.css(_elemStart.firstChild, {
"border-bottom-width" : v ? 1 : 0,
"border-right-width" : v ? 0 : 1,
"bottom": v ? -1 : options.indent,
"right": v ? options.indent : -1,
"padding": v ? "0 8px" : "2px 4px",
});
_util.css(_elemEnd, {
"border-top-width" : v ? 1 : 0,
"border-left-width" : v ? 0 : 1,
"top": v ? "100%" : "",
"right": v ? options.indent : "",
"bottom": v ? "" : options.indent,
"left": v ? "" : "100%",
"padding": v ? "0 8px" : "2px 4px"
});
// append
_boundsContainer.appendChild(_elemBounds);
};
// remove bounds from list and DOM
var removeBounds = function () {
_elemBounds.parentNode.removeChild(_elemBounds);
};
// update the start and end positions of the scene
var updateBounds = function () {
if (_elemBounds.parentNode !== _boundsContainer) {
addBounds(); // Add Bounds elements (start/end)
}
var css = {};
css[_vertical ? "top" : "left"] = Scene.triggerPosition();
css[_vertical ? "height" : "width"] = Scene.duration();
_util.css(_elemBounds, css);
_util.css(_elemEnd, {
display: Scene.duration() > 0 ? "" : "none"
});
};
/*
* ----------------------------------------------------------------
* trigger and trigger group management
* ----------------------------------------------------------------
*/
// adds an new trigger group to the array and to the DOM
var addTriggerGroup = function () {
var triggerElem = TPL.trigger(options.colorTrigger); // new trigger element
var css = {};
css[_vertical ? "right" : "bottom"] = 0;
css[_vertical ? "border-top-width" : "border-left-width"] = 1;
_util.css(triggerElem.firstChild, css);
_util.css(triggerElem.firstChild.firstChild, {
padding: _vertical ? "0 8px 3px 8px" : "3px 4px"
});
document.body.appendChild(triggerElem); // directly add to body
var newGroup = {
triggerHook: Scene.triggerHook(),
element: triggerElem,
members: [Indicator]
};
_ctrl._indicators.groups.push(newGroup);
Indicator.triggerGroup = newGroup;
// update right away
_ctrl._indicators.updateTriggerGroupLabel(newGroup);
_ctrl._indicators.updateTriggerGroupPositions(newGroup);
};
var removeTriggerGroup = function () {
_ctrl._indicators.groups.splice(_ctrl._indicators.groups.indexOf(Indicator.triggerGroup), 1);
Indicator.triggerGroup.element.parentNode.removeChild(Indicator.triggerGroup.element);
Indicator.triggerGroup = undefined;
};
// updates the trigger group -> either join existing or add new one
/*
* Logic:
* 1 if a trigger group exist, check if it's in sync with Scene settings – if so, nothing else needs to happen
* 2 try to find an existing one that matches Scene parameters
* 2.1 If a match is found check if already assigned to an existing group
* If so:
* A: it was the last member of existing group -> kill whole group
* B: the existing group has other members -> just remove from member list
* 2.2 Assign to matching group
* 3 if no new match could be found, check if assigned to existing group
* A: yes, and it's the only member -> just update parameters and positions and keep using this group
* B: yes but there are other members -> remove from member list and create a new one
* C: no, so create a new one
*/
var updateTriggerGroup = function () {
var
triggerHook = Scene.triggerHook(),
closeEnough = 0.0001;
// Have a group, check if it still matches
if (Indicator.triggerGroup) {
if (Math.abs(Indicator.triggerGroup.triggerHook - triggerHook) < closeEnough) {
// _util.log(0, "trigger", options.name, "->", "no need to change, still in sync");
return; // all good
}
}
// Don't have a group, check if a matching one exists
// _util.log(0, "trigger", options.name, "->", "out of sync!");
var
groups = _ctrl._indicators.groups,
group,
i = groups.length;
while (i--) {
group = groups[i];
if (Math.abs(group.triggerHook - triggerHook) < closeEnough) {
// found a match!
// _util.log(0, "trigger", options.name, "->", "found match");
if (Indicator.triggerGroup) { // do I have an old group that is out of sync?
if (Indicator.triggerGroup.members.length === 1) { // is it the only remaining group?
// _util.log(0, "trigger", options.name, "->", "kill");
// was the last member, remove the whole group
removeTriggerGroup();
} else {
Indicator.triggerGroup.members.splice(Indicator.triggerGroup.members.indexOf(Indicator), 1); // just remove from memberlist of old group
_ctrl._indicators.updateTriggerGroupLabel(Indicator.triggerGroup);
_ctrl._indicators.updateTriggerGroupPositions(Indicator.triggerGroup);
// _util.log(0, "trigger", options.name, "->", "removing from previous member list");
}
}
// join new group
group.members.push(Indicator);
Indicator.triggerGroup = group;
_ctrl._indicators.updateTriggerGroupLabel(group);
return;
}
}
// at this point I am obviously out of sync and don't match any other group
if (Indicator.triggerGroup) {
if (Indicator.triggerGroup.members.length === 1) {
// _util.log(0, "trigger", options.name, "->", "updating existing");
// out of sync but i'm the only member => just change and update
Indicator.triggerGroup.triggerHook = triggerHook;
_ctrl._indicators.updateTriggerGroupPositions(Indicator.triggerGroup);
return;
} else {
// _util.log(0, "trigger", options.name, "->", "removing from previous member list");
Indicator.triggerGroup.members.splice(Indicator.triggerGroup.members.indexOf(Indicator), 1); // just remove from memberlist of old group
_ctrl._indicators.updateTriggerGroupLabel(Indicator.triggerGroup);
_ctrl._indicators.updateTriggerGroupPositions(Indicator.triggerGroup);
Indicator.triggerGroup = undefined; // need a brand new group...
}
}
// _util.log(0, "trigger", options.name, "->", "add a new one");
// did not find any match, make new trigger group
addTriggerGroup();
};
};
/*
* ----------------------------------------------------------------
* Templates for the indicators
* ----------------------------------------------------------------
*/
var TPL = {
start: function (color) {
// inner element (for bottom offset -1, while keeping top position 0)
var inner = document.createElement("div");
inner.textContent = "start";
_util.css(inner, {
position: "absolute",
overflow: "visible",
display: "none",
"border-width" : 0,
"border-style" : "solid",
color: color,
"border-color" : color
});
var e = document.createElement('div');
// wrapper
_util.css(e, {
position: "absolute",
overflow: "visible",
width: 0,
height: 0
});
e.appendChild(inner);
return e;
},
end: function (color) {
var e = document.createElement('div');
e.textContent = "end";
_util.css(e, {
position: "absolute",
overflow: "visible",
display: "none",
"border-width" : 0,
"border-style" : "solid",
color: color,
"border-color" : color
});
return e;
},
bounds: function () {
var e = document.createElement('div');
_util.css(e, {
position: "absolute",
overflow: "visible",
display: "none",
"white-space": "nowrap",
"pointer-events" : "none",
"font-size": FONT_SIZE
});
e.style.zIndex = ZINDEX;
return e;
},
trigger: function (color) {
// inner to be above or below line but keep position
var inner = document.createElement('div');
inner.textContent = "trigger";
_util.css(inner, {
position: "relative",
});
// inner wrapper for right: 0 and main element has no size
var w = document.createElement('div');
_util.css(w, {
position: "absolute",
overflow: "visible",
display: "none",
"border-width" : 0,
"border-style" : "solid",
color: color,
"border-color" : color
});
w.appendChild(inner);
// wrapper
var e = document.createElement('div');
_util.css(e, {
position: "fixed",
overflow: "visible",
"white-space": "nowrap",
"pointer-events" : "none",
"font-size": FONT_SIZE
});
e.style.zIndex = ZINDEX;
e.appendChild(w);
return e;
},
};
}));