malte_langkabel
837fb24dc6
* added the initial setup for mediacube page. * using mysql as database and foundation for layout support.
1583 lines
47 KiB
JavaScript
1583 lines
47 KiB
JavaScript
/*
|
|
* Foundation Responsive Library
|
|
* http://foundation.zurb.com
|
|
* Copyright 2014, ZURB
|
|
* Free to use under the MIT license.
|
|
* http://www.opensource.org/licenses/mit-license.php
|
|
*/
|
|
|
|
(function ($, window, document, undefined) {
|
|
'use strict';
|
|
|
|
var header_helpers = function (class_array) {
|
|
var i = class_array.length;
|
|
var head = $('head');
|
|
|
|
while (i--) {
|
|
if (head.has('.' + class_array[i]).length === 0) {
|
|
head.append('<meta class="' + class_array[i] + '" />');
|
|
}
|
|
}
|
|
};
|
|
|
|
header_helpers([
|
|
'foundation-mq-small',
|
|
'foundation-mq-small-only',
|
|
'foundation-mq-medium',
|
|
'foundation-mq-medium-only',
|
|
'foundation-mq-large',
|
|
'foundation-mq-large-only',
|
|
'foundation-mq-xlarge',
|
|
'foundation-mq-xlarge-only',
|
|
'foundation-mq-xxlarge',
|
|
'foundation-data-attribute-namespace']);
|
|
|
|
// Enable FastClick if present
|
|
|
|
$(function () {
|
|
if (typeof FastClick !== 'undefined') {
|
|
// Don't attach to body if undefined
|
|
if (typeof document.body !== 'undefined') {
|
|
FastClick.attach(document.body);
|
|
}
|
|
}
|
|
});
|
|
|
|
// private Fast Selector wrapper,
|
|
// returns jQuery object. Only use where
|
|
// getElementById is not available.
|
|
var S = function (selector, context) {
|
|
if (typeof selector === 'string') {
|
|
if (context) {
|
|
var cont;
|
|
if (context.jquery) {
|
|
cont = context[0];
|
|
if (!cont) {
|
|
return context;
|
|
}
|
|
} else {
|
|
cont = context;
|
|
}
|
|
return $(cont.querySelectorAll(selector));
|
|
}
|
|
|
|
return $(document.querySelectorAll(selector));
|
|
}
|
|
|
|
return $(selector, context);
|
|
};
|
|
|
|
// Namespace functions.
|
|
|
|
var attr_name = function (init) {
|
|
var arr = [];
|
|
if (!init) {
|
|
arr.push('data');
|
|
}
|
|
if (this.namespace.length > 0) {
|
|
arr.push(this.namespace);
|
|
}
|
|
arr.push(this.name);
|
|
|
|
return arr.join('-');
|
|
};
|
|
|
|
var add_namespace = function (str) {
|
|
var parts = str.split('-'),
|
|
i = parts.length,
|
|
arr = [];
|
|
|
|
while (i--) {
|
|
if (i !== 0) {
|
|
arr.push(parts[i]);
|
|
} else {
|
|
if (this.namespace.length > 0) {
|
|
arr.push(this.namespace, parts[i]);
|
|
} else {
|
|
arr.push(parts[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return arr.reverse().join('-');
|
|
};
|
|
|
|
// Event binding and data-options updating.
|
|
|
|
var bindings = function (method, options) {
|
|
var self = this,
|
|
bind = function(){
|
|
var $this = S(this),
|
|
should_bind_events = !$this.data(self.attr_name(true) + '-init');
|
|
$this.data(self.attr_name(true) + '-init', $.extend({}, self.settings, (options || method), self.data_options($this)));
|
|
|
|
if (should_bind_events) {
|
|
self.events(this);
|
|
}
|
|
};
|
|
|
|
if (S(this.scope).is('[' + this.attr_name() +']')) {
|
|
bind.call(this.scope);
|
|
} else {
|
|
S('[' + this.attr_name() +']', this.scope).each(bind);
|
|
}
|
|
// # Patch to fix #5043 to move this *after* the if/else clause in order for Backbone and similar frameworks to have improved control over event binding and data-options updating.
|
|
if (typeof method === 'string') {
|
|
return this[method].call(this, options);
|
|
}
|
|
|
|
};
|
|
|
|
var single_image_loaded = function (image, callback) {
|
|
function loaded () {
|
|
callback(image[0]);
|
|
}
|
|
|
|
function bindLoad () {
|
|
this.one('load', loaded);
|
|
|
|
if (/MSIE (\d+\.\d+);/.test(navigator.userAgent)) {
|
|
var src = this.attr( 'src' ),
|
|
param = src.match( /\?/ ) ? '&' : '?';
|
|
|
|
param += 'random=' + (new Date()).getTime();
|
|
this.attr('src', src + param);
|
|
}
|
|
}
|
|
|
|
if (!image.attr('src')) {
|
|
loaded();
|
|
return;
|
|
}
|
|
|
|
if (image[0].complete || image[0].readyState === 4) {
|
|
loaded();
|
|
} else {
|
|
bindLoad.call(image);
|
|
}
|
|
};
|
|
|
|
/*! matchMedia() polyfill - Test a CSS media type/query in JS. Authors & copyright (c) 2012: Scott Jehl, Paul Irish, Nicholas Zakas, David Knight. Dual MIT/BSD license */
|
|
|
|
window.matchMedia || (window.matchMedia = function() {
|
|
"use strict";
|
|
|
|
// For browsers that support matchMedium api such as IE 9 and webkit
|
|
var styleMedia = (window.styleMedia || window.media);
|
|
|
|
// For those that don't support matchMedium
|
|
if (!styleMedia) {
|
|
var style = document.createElement('style'),
|
|
script = document.getElementsByTagName('script')[0],
|
|
info = null;
|
|
|
|
style.type = 'text/css';
|
|
style.id = 'matchmediajs-test';
|
|
|
|
script.parentNode.insertBefore(style, script);
|
|
|
|
// 'style.currentStyle' is used by IE <= 8 and 'window.getComputedStyle' for all other browsers
|
|
info = ('getComputedStyle' in window) && window.getComputedStyle(style, null) || style.currentStyle;
|
|
|
|
styleMedia = {
|
|
matchMedium: function(media) {
|
|
var text = '@media ' + media + '{ #matchmediajs-test { width: 1px; } }';
|
|
|
|
// 'style.styleSheet' is used by IE <= 8 and 'style.textContent' for all other browsers
|
|
if (style.styleSheet) {
|
|
style.styleSheet.cssText = text;
|
|
} else {
|
|
style.textContent = text;
|
|
}
|
|
|
|
// Test if media query is true or false
|
|
return info.width === '1px';
|
|
}
|
|
};
|
|
}
|
|
|
|
return function(media) {
|
|
return {
|
|
matches: styleMedia.matchMedium(media || 'all'),
|
|
media: media || 'all'
|
|
};
|
|
};
|
|
}());
|
|
|
|
/*
|
|
* jquery.requestAnimationFrame
|
|
* https://github.com/gnarf37/jquery-requestAnimationFrame
|
|
* Requires jQuery 1.8+
|
|
*
|
|
* Copyright (c) 2012 Corey Frang
|
|
* Licensed under the MIT license.
|
|
*/
|
|
|
|
(function(jQuery) {
|
|
|
|
|
|
// requestAnimationFrame polyfill adapted from Erik Möller
|
|
// fixes from Paul Irish and Tino Zijdel
|
|
// http://paulirish.com/2011/requestanimationframe-for-smart-animating/
|
|
// http://my.opera.com/emoller/blog/2011/12/20/requestanimationframe-for-smart-er-animating
|
|
|
|
var animating,
|
|
lastTime = 0,
|
|
vendors = ['webkit', 'moz'],
|
|
requestAnimationFrame = window.requestAnimationFrame,
|
|
cancelAnimationFrame = window.cancelAnimationFrame,
|
|
jqueryFxAvailable = 'undefined' !== typeof jQuery.fx;
|
|
|
|
for (; lastTime < vendors.length && !requestAnimationFrame; lastTime++) {
|
|
requestAnimationFrame = window[ vendors[lastTime] + 'RequestAnimationFrame' ];
|
|
cancelAnimationFrame = cancelAnimationFrame ||
|
|
window[ vendors[lastTime] + 'CancelAnimationFrame' ] ||
|
|
window[ vendors[lastTime] + 'CancelRequestAnimationFrame' ];
|
|
}
|
|
|
|
function raf() {
|
|
if (animating) {
|
|
requestAnimationFrame(raf);
|
|
|
|
if (jqueryFxAvailable) {
|
|
jQuery.fx.tick();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (requestAnimationFrame) {
|
|
// use rAF
|
|
window.requestAnimationFrame = requestAnimationFrame;
|
|
window.cancelAnimationFrame = cancelAnimationFrame;
|
|
|
|
if (jqueryFxAvailable) {
|
|
jQuery.fx.timer = function (timer) {
|
|
if (timer() && jQuery.timers.push(timer) && !animating) {
|
|
animating = true;
|
|
raf();
|
|
}
|
|
};
|
|
|
|
jQuery.fx.stop = function () {
|
|
animating = false;
|
|
};
|
|
}
|
|
} else {
|
|
// polyfill
|
|
window.requestAnimationFrame = function (callback) {
|
|
var currTime = new Date().getTime(),
|
|
timeToCall = Math.max(0, 16 - (currTime - lastTime)),
|
|
id = window.setTimeout(function () {
|
|
callback(currTime + timeToCall);
|
|
}, timeToCall);
|
|
lastTime = currTime + timeToCall;
|
|
return id;
|
|
};
|
|
|
|
window.cancelAnimationFrame = function (id) {
|
|
clearTimeout(id);
|
|
};
|
|
|
|
}
|
|
|
|
}( $ ));
|
|
|
|
function removeQuotes (string) {
|
|
if (typeof string === 'string' || string instanceof String) {
|
|
string = string.replace(/^['\\/"]+|(;\s?})+|['\\/"]+$/g, '');
|
|
}
|
|
|
|
return string;
|
|
}
|
|
|
|
window.Foundation = {
|
|
name : 'Foundation',
|
|
|
|
version : '5.5.2',
|
|
|
|
media_queries : {
|
|
'small' : S('.foundation-mq-small').css('font-family').replace(/^[\/\\'"]+|(;\s?})+|[\/\\'"]+$/g, ''),
|
|
'small-only' : S('.foundation-mq-small-only').css('font-family').replace(/^[\/\\'"]+|(;\s?})+|[\/\\'"]+$/g, ''),
|
|
'medium' : S('.foundation-mq-medium').css('font-family').replace(/^[\/\\'"]+|(;\s?})+|[\/\\'"]+$/g, ''),
|
|
'medium-only' : S('.foundation-mq-medium-only').css('font-family').replace(/^[\/\\'"]+|(;\s?})+|[\/\\'"]+$/g, ''),
|
|
'large' : S('.foundation-mq-large').css('font-family').replace(/^[\/\\'"]+|(;\s?})+|[\/\\'"]+$/g, ''),
|
|
'large-only' : S('.foundation-mq-large-only').css('font-family').replace(/^[\/\\'"]+|(;\s?})+|[\/\\'"]+$/g, ''),
|
|
'xlarge' : S('.foundation-mq-xlarge').css('font-family').replace(/^[\/\\'"]+|(;\s?})+|[\/\\'"]+$/g, ''),
|
|
'xlarge-only' : S('.foundation-mq-xlarge-only').css('font-family').replace(/^[\/\\'"]+|(;\s?})+|[\/\\'"]+$/g, ''),
|
|
'xxlarge' : S('.foundation-mq-xxlarge').css('font-family').replace(/^[\/\\'"]+|(;\s?})+|[\/\\'"]+$/g, '')
|
|
},
|
|
|
|
stylesheet : $('<style></style>').appendTo('head')[0].sheet,
|
|
|
|
global : {
|
|
namespace : undefined
|
|
},
|
|
|
|
init : function (scope, libraries, method, options, response) {
|
|
var args = [scope, method, options, response],
|
|
responses = [];
|
|
|
|
// check RTL
|
|
this.rtl = /rtl/i.test(S('html').attr('dir'));
|
|
|
|
// set foundation global scope
|
|
this.scope = scope || this.scope;
|
|
|
|
this.set_namespace();
|
|
|
|
if (libraries && typeof libraries === 'string' && !/reflow/i.test(libraries)) {
|
|
if (this.libs.hasOwnProperty(libraries)) {
|
|
responses.push(this.init_lib(libraries, args));
|
|
}
|
|
} else {
|
|
for (var lib in this.libs) {
|
|
responses.push(this.init_lib(lib, libraries));
|
|
}
|
|
}
|
|
|
|
S(window).load(function () {
|
|
S(window)
|
|
.trigger('resize.fndtn.clearing')
|
|
.trigger('resize.fndtn.dropdown')
|
|
.trigger('resize.fndtn.equalizer')
|
|
.trigger('resize.fndtn.interchange')
|
|
.trigger('resize.fndtn.joyride')
|
|
.trigger('resize.fndtn.magellan')
|
|
.trigger('resize.fndtn.topbar')
|
|
.trigger('resize.fndtn.slider');
|
|
});
|
|
|
|
return scope;
|
|
},
|
|
|
|
init_lib : function (lib, args) {
|
|
if (this.libs.hasOwnProperty(lib)) {
|
|
this.patch(this.libs[lib]);
|
|
|
|
if (args && args.hasOwnProperty(lib)) {
|
|
if (typeof this.libs[lib].settings !== 'undefined') {
|
|
$.extend(true, this.libs[lib].settings, args[lib]);
|
|
} else if (typeof this.libs[lib].defaults !== 'undefined') {
|
|
$.extend(true, this.libs[lib].defaults, args[lib]);
|
|
}
|
|
return this.libs[lib].init.apply(this.libs[lib], [this.scope, args[lib]]);
|
|
}
|
|
|
|
args = args instanceof Array ? args : new Array(args);
|
|
return this.libs[lib].init.apply(this.libs[lib], args);
|
|
}
|
|
|
|
return function () {};
|
|
},
|
|
|
|
patch : function (lib) {
|
|
lib.scope = this.scope;
|
|
lib.namespace = this.global.namespace;
|
|
lib.rtl = this.rtl;
|
|
lib['data_options'] = this.utils.data_options;
|
|
lib['attr_name'] = attr_name;
|
|
lib['add_namespace'] = add_namespace;
|
|
lib['bindings'] = bindings;
|
|
lib['S'] = this.utils.S;
|
|
},
|
|
|
|
inherit : function (scope, methods) {
|
|
var methods_arr = methods.split(' '),
|
|
i = methods_arr.length;
|
|
|
|
while (i--) {
|
|
if (this.utils.hasOwnProperty(methods_arr[i])) {
|
|
scope[methods_arr[i]] = this.utils[methods_arr[i]];
|
|
}
|
|
}
|
|
},
|
|
|
|
set_namespace : function () {
|
|
|
|
// Description:
|
|
// Don't bother reading the namespace out of the meta tag
|
|
// if the namespace has been set globally in javascript
|
|
//
|
|
// Example:
|
|
// Foundation.global.namespace = 'my-namespace';
|
|
// or make it an empty string:
|
|
// Foundation.global.namespace = '';
|
|
//
|
|
//
|
|
|
|
// If the namespace has not been set (is undefined), try to read it out of the meta element.
|
|
// Otherwise use the globally defined namespace, even if it's empty ('')
|
|
var namespace = ( this.global.namespace === undefined ) ? $('.foundation-data-attribute-namespace').css('font-family') : this.global.namespace;
|
|
|
|
// Finally, if the namsepace is either undefined or false, set it to an empty string.
|
|
// Otherwise use the namespace value.
|
|
this.global.namespace = ( namespace === undefined || /false/i.test(namespace) ) ? '' : namespace;
|
|
},
|
|
|
|
libs : {},
|
|
|
|
// methods that can be inherited in libraries
|
|
utils : {
|
|
|
|
// Description:
|
|
// Fast Selector wrapper returns jQuery object. Only use where getElementById
|
|
// is not available.
|
|
//
|
|
// Arguments:
|
|
// Selector (String): CSS selector describing the element(s) to be
|
|
// returned as a jQuery object.
|
|
//
|
|
// Scope (String): CSS selector describing the area to be searched. Default
|
|
// is document.
|
|
//
|
|
// Returns:
|
|
// Element (jQuery Object): jQuery object containing elements matching the
|
|
// selector within the scope.
|
|
S : S,
|
|
|
|
// Description:
|
|
// Executes a function a max of once every n milliseconds
|
|
//
|
|
// Arguments:
|
|
// Func (Function): Function to be throttled.
|
|
//
|
|
// Delay (Integer): Function execution threshold in milliseconds.
|
|
//
|
|
// Returns:
|
|
// Lazy_function (Function): Function with throttling applied.
|
|
throttle : function (func, delay) {
|
|
var timer = null;
|
|
|
|
return function () {
|
|
var context = this, args = arguments;
|
|
|
|
if (timer == null) {
|
|
timer = setTimeout(function () {
|
|
func.apply(context, args);
|
|
timer = null;
|
|
}, delay);
|
|
}
|
|
};
|
|
},
|
|
|
|
// Description:
|
|
// Executes a function when it stops being invoked for n seconds
|
|
// Modified version of _.debounce() http://underscorejs.org
|
|
//
|
|
// Arguments:
|
|
// Func (Function): Function to be debounced.
|
|
//
|
|
// Delay (Integer): Function execution threshold in milliseconds.
|
|
//
|
|
// Immediate (Bool): Whether the function should be called at the beginning
|
|
// of the delay instead of the end. Default is false.
|
|
//
|
|
// Returns:
|
|
// Lazy_function (Function): Function with debouncing applied.
|
|
debounce : function (func, delay, immediate) {
|
|
var timeout, result;
|
|
return function () {
|
|
var context = this, args = arguments;
|
|
var later = function () {
|
|
timeout = null;
|
|
if (!immediate) {
|
|
result = func.apply(context, args);
|
|
}
|
|
};
|
|
var callNow = immediate && !timeout;
|
|
clearTimeout(timeout);
|
|
timeout = setTimeout(later, delay);
|
|
if (callNow) {
|
|
result = func.apply(context, args);
|
|
}
|
|
return result;
|
|
};
|
|
},
|
|
|
|
// Description:
|
|
// Parses data-options attribute
|
|
//
|
|
// Arguments:
|
|
// El (jQuery Object): Element to be parsed.
|
|
//
|
|
// Returns:
|
|
// Options (Javascript Object): Contents of the element's data-options
|
|
// attribute.
|
|
data_options : function (el, data_attr_name) {
|
|
data_attr_name = data_attr_name || 'options';
|
|
var opts = {}, ii, p, opts_arr,
|
|
data_options = function (el) {
|
|
var namespace = Foundation.global.namespace;
|
|
|
|
if (namespace.length > 0) {
|
|
return el.data(namespace + '-' + data_attr_name);
|
|
}
|
|
|
|
return el.data(data_attr_name);
|
|
};
|
|
|
|
var cached_options = data_options(el);
|
|
|
|
if (typeof cached_options === 'object') {
|
|
return cached_options;
|
|
}
|
|
|
|
opts_arr = (cached_options || ':').split(';');
|
|
ii = opts_arr.length;
|
|
|
|
function isNumber (o) {
|
|
return !isNaN (o - 0) && o !== null && o !== '' && o !== false && o !== true;
|
|
}
|
|
|
|
function trim (str) {
|
|
if (typeof str === 'string') {
|
|
return $.trim(str);
|
|
}
|
|
return str;
|
|
}
|
|
|
|
while (ii--) {
|
|
p = opts_arr[ii].split(':');
|
|
p = [p[0], p.slice(1).join(':')];
|
|
|
|
if (/true/i.test(p[1])) {
|
|
p[1] = true;
|
|
}
|
|
if (/false/i.test(p[1])) {
|
|
p[1] = false;
|
|
}
|
|
if (isNumber(p[1])) {
|
|
if (p[1].indexOf('.') === -1) {
|
|
p[1] = parseInt(p[1], 10);
|
|
} else {
|
|
p[1] = parseFloat(p[1]);
|
|
}
|
|
}
|
|
|
|
if (p.length === 2 && p[0].length > 0) {
|
|
opts[trim(p[0])] = trim(p[1]);
|
|
}
|
|
}
|
|
|
|
return opts;
|
|
},
|
|
|
|
// Description:
|
|
// Adds JS-recognizable media queries
|
|
//
|
|
// Arguments:
|
|
// Media (String): Key string for the media query to be stored as in
|
|
// Foundation.media_queries
|
|
//
|
|
// Class (String): Class name for the generated <meta> tag
|
|
register_media : function (media, media_class) {
|
|
if (Foundation.media_queries[media] === undefined) {
|
|
$('head').append('<meta class="' + media_class + '"/>');
|
|
Foundation.media_queries[media] = removeQuotes($('.' + media_class).css('font-family'));
|
|
}
|
|
},
|
|
|
|
// Description:
|
|
// Add custom CSS within a JS-defined media query
|
|
//
|
|
// Arguments:
|
|
// Rule (String): CSS rule to be appended to the document.
|
|
//
|
|
// Media (String): Optional media query string for the CSS rule to be
|
|
// nested under.
|
|
add_custom_rule : function (rule, media) {
|
|
if (media === undefined && Foundation.stylesheet) {
|
|
Foundation.stylesheet.insertRule(rule, Foundation.stylesheet.cssRules.length);
|
|
} else {
|
|
var query = Foundation.media_queries[media];
|
|
|
|
if (query !== undefined) {
|
|
Foundation.stylesheet.insertRule('@media ' +
|
|
Foundation.media_queries[media] + '{ ' + rule + ' }', Foundation.stylesheet.cssRules.length);
|
|
}
|
|
}
|
|
},
|
|
|
|
// Description:
|
|
// Performs a callback function when an image is fully loaded
|
|
//
|
|
// Arguments:
|
|
// Image (jQuery Object): Image(s) to check if loaded.
|
|
//
|
|
// Callback (Function): Function to execute when image is fully loaded.
|
|
image_loaded : function (images, callback) {
|
|
var self = this,
|
|
unloaded = images.length;
|
|
|
|
function pictures_has_height(images) {
|
|
var pictures_number = images.length;
|
|
|
|
for (var i = pictures_number - 1; i >= 0; i--) {
|
|
if(images.attr('height') === undefined) {
|
|
return false;
|
|
};
|
|
};
|
|
|
|
return true;
|
|
}
|
|
|
|
if (unloaded === 0 || pictures_has_height(images)) {
|
|
callback(images);
|
|
}
|
|
|
|
images.each(function () {
|
|
single_image_loaded(self.S(this), function () {
|
|
unloaded -= 1;
|
|
if (unloaded === 0) {
|
|
callback(images);
|
|
}
|
|
});
|
|
});
|
|
},
|
|
|
|
// Description:
|
|
// Returns a random, alphanumeric string
|
|
//
|
|
// Arguments:
|
|
// Length (Integer): Length of string to be generated. Defaults to random
|
|
// integer.
|
|
//
|
|
// Returns:
|
|
// Rand (String): Pseudo-random, alphanumeric string.
|
|
random_str : function () {
|
|
if (!this.fidx) {
|
|
this.fidx = 0;
|
|
}
|
|
this.prefix = this.prefix || [(this.name || 'F'), (+new Date).toString(36)].join('-');
|
|
|
|
return this.prefix + (this.fidx++).toString(36);
|
|
},
|
|
|
|
// Description:
|
|
// Helper for window.matchMedia
|
|
//
|
|
// Arguments:
|
|
// mq (String): Media query
|
|
//
|
|
// Returns:
|
|
// (Boolean): Whether the media query passes or not
|
|
match : function (mq) {
|
|
return window.matchMedia(mq).matches;
|
|
},
|
|
|
|
// Description:
|
|
// Helpers for checking Foundation default media queries with JS
|
|
//
|
|
// Returns:
|
|
// (Boolean): Whether the media query passes or not
|
|
|
|
is_small_up : function () {
|
|
return this.match(Foundation.media_queries.small);
|
|
},
|
|
|
|
is_medium_up : function () {
|
|
return this.match(Foundation.media_queries.medium);
|
|
},
|
|
|
|
is_large_up : function () {
|
|
return this.match(Foundation.media_queries.large);
|
|
},
|
|
|
|
is_xlarge_up : function () {
|
|
return this.match(Foundation.media_queries.xlarge);
|
|
},
|
|
|
|
is_xxlarge_up : function () {
|
|
return this.match(Foundation.media_queries.xxlarge);
|
|
},
|
|
|
|
is_small_only : function () {
|
|
return !this.is_medium_up() && !this.is_large_up() && !this.is_xlarge_up() && !this.is_xxlarge_up();
|
|
},
|
|
|
|
is_medium_only : function () {
|
|
return this.is_medium_up() && !this.is_large_up() && !this.is_xlarge_up() && !this.is_xxlarge_up();
|
|
},
|
|
|
|
is_large_only : function () {
|
|
return this.is_medium_up() && this.is_large_up() && !this.is_xlarge_up() && !this.is_xxlarge_up();
|
|
},
|
|
|
|
is_xlarge_only : function () {
|
|
return this.is_medium_up() && this.is_large_up() && this.is_xlarge_up() && !this.is_xxlarge_up();
|
|
},
|
|
|
|
is_xxlarge_only : function () {
|
|
return this.is_medium_up() && this.is_large_up() && this.is_xlarge_up() && this.is_xxlarge_up();
|
|
}
|
|
}
|
|
};
|
|
|
|
$.fn.foundation = function () {
|
|
var args = Array.prototype.slice.call(arguments, 0);
|
|
|
|
return this.each(function () {
|
|
Foundation.init.apply(Foundation, [this].concat(args));
|
|
return this;
|
|
});
|
|
};
|
|
|
|
}(jQuery, window, window.document));
|
|
;(function ($, window, document, undefined) {
|
|
'use strict';
|
|
|
|
Foundation.libs.reveal = {
|
|
name : 'reveal',
|
|
|
|
version : '5.5.2',
|
|
|
|
locked : false,
|
|
|
|
settings : {
|
|
animation : 'fadeAndPop',
|
|
animation_speed : 250,
|
|
close_on_background_click : true,
|
|
close_on_esc : true,
|
|
dismiss_modal_class : 'close-reveal-modal',
|
|
multiple_opened : false,
|
|
bg_class : 'reveal-modal-bg',
|
|
root_element : 'body',
|
|
open : function(){},
|
|
opened : function(){},
|
|
close : function(){},
|
|
closed : function(){},
|
|
on_ajax_error: $.noop,
|
|
bg : $('.reveal-modal-bg'),
|
|
css : {
|
|
open : {
|
|
'opacity' : 0,
|
|
'visibility' : 'visible',
|
|
'display' : 'block'
|
|
},
|
|
close : {
|
|
'opacity' : 1,
|
|
'visibility' : 'hidden',
|
|
'display' : 'none'
|
|
}
|
|
}
|
|
},
|
|
|
|
init : function (scope, method, options) {
|
|
$.extend(true, this.settings, method, options);
|
|
this.bindings(method, options);
|
|
},
|
|
|
|
events : function (scope) {
|
|
var self = this,
|
|
S = self.S;
|
|
|
|
S(this.scope)
|
|
.off('.reveal')
|
|
.on('click.fndtn.reveal', '[' + this.add_namespace('data-reveal-id') + ']:not([disabled])', function (e) {
|
|
e.preventDefault();
|
|
|
|
if (!self.locked) {
|
|
var element = S(this),
|
|
ajax = element.data(self.data_attr('reveal-ajax')),
|
|
replaceContentSel = element.data(self.data_attr('reveal-replace-content'));
|
|
|
|
self.locked = true;
|
|
|
|
if (typeof ajax === 'undefined') {
|
|
self.open.call(self, element);
|
|
} else {
|
|
var url = ajax === true ? element.attr('href') : ajax;
|
|
self.open.call(self, element, {url : url}, { replaceContentSel : replaceContentSel });
|
|
}
|
|
}
|
|
});
|
|
|
|
S(document)
|
|
.on('click.fndtn.reveal', this.close_targets(), function (e) {
|
|
e.preventDefault();
|
|
if (!self.locked) {
|
|
var settings = S('[' + self.attr_name() + '].open').data(self.attr_name(true) + '-init') || self.settings,
|
|
bg_clicked = S(e.target)[0] === S('.' + settings.bg_class)[0];
|
|
|
|
if (bg_clicked) {
|
|
if (settings.close_on_background_click) {
|
|
e.stopPropagation();
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
self.locked = true;
|
|
self.close.call(self, bg_clicked ? S('[' + self.attr_name() + '].open:not(.toback)') : S(this).closest('[' + self.attr_name() + ']'));
|
|
}
|
|
});
|
|
|
|
if (S('[' + self.attr_name() + ']', this.scope).length > 0) {
|
|
S(this.scope)
|
|
// .off('.reveal')
|
|
.on('open.fndtn.reveal', this.settings.open)
|
|
.on('opened.fndtn.reveal', this.settings.opened)
|
|
.on('opened.fndtn.reveal', this.open_video)
|
|
.on('close.fndtn.reveal', this.settings.close)
|
|
.on('closed.fndtn.reveal', this.settings.closed)
|
|
.on('closed.fndtn.reveal', this.close_video);
|
|
} else {
|
|
S(this.scope)
|
|
// .off('.reveal')
|
|
.on('open.fndtn.reveal', '[' + self.attr_name() + ']', this.settings.open)
|
|
.on('opened.fndtn.reveal', '[' + self.attr_name() + ']', this.settings.opened)
|
|
.on('opened.fndtn.reveal', '[' + self.attr_name() + ']', this.open_video)
|
|
.on('close.fndtn.reveal', '[' + self.attr_name() + ']', this.settings.close)
|
|
.on('closed.fndtn.reveal', '[' + self.attr_name() + ']', this.settings.closed)
|
|
.on('closed.fndtn.reveal', '[' + self.attr_name() + ']', this.close_video);
|
|
}
|
|
|
|
return true;
|
|
},
|
|
|
|
// PATCH #3: turning on key up capture only when a reveal window is open
|
|
key_up_on : function (scope) {
|
|
var self = this;
|
|
|
|
// PATCH #1: fixing multiple keyup event trigger from single key press
|
|
self.S('body').off('keyup.fndtn.reveal').on('keyup.fndtn.reveal', function ( event ) {
|
|
var open_modal = self.S('[' + self.attr_name() + '].open'),
|
|
settings = open_modal.data(self.attr_name(true) + '-init') || self.settings ;
|
|
// PATCH #2: making sure that the close event can be called only while unlocked,
|
|
// so that multiple keyup.fndtn.reveal events don't prevent clean closing of the reveal window.
|
|
if ( settings && event.which === 27 && settings.close_on_esc && !self.locked) { // 27 is the keycode for the Escape key
|
|
self.close.call(self, open_modal);
|
|
}
|
|
});
|
|
|
|
return true;
|
|
},
|
|
|
|
// PATCH #3: turning on key up capture only when a reveal window is open
|
|
key_up_off : function (scope) {
|
|
this.S('body').off('keyup.fndtn.reveal');
|
|
return true;
|
|
},
|
|
|
|
open : function (target, ajax_settings) {
|
|
var self = this,
|
|
modal;
|
|
|
|
if (target) {
|
|
if (typeof target.selector !== 'undefined') {
|
|
// Find the named node; only use the first one found, since the rest of the code assumes there's only one node
|
|
modal = self.S('#' + target.data(self.data_attr('reveal-id'))).first();
|
|
} else {
|
|
modal = self.S(this.scope);
|
|
|
|
ajax_settings = target;
|
|
}
|
|
} else {
|
|
modal = self.S(this.scope);
|
|
}
|
|
|
|
var settings = modal.data(self.attr_name(true) + '-init');
|
|
settings = settings || this.settings;
|
|
|
|
|
|
if (modal.hasClass('open') && target.attr('data-reveal-id') == modal.attr('id')) {
|
|
return self.close(modal);
|
|
}
|
|
|
|
if (!modal.hasClass('open')) {
|
|
var open_modal = self.S('[' + self.attr_name() + '].open');
|
|
|
|
if (typeof modal.data('css-top') === 'undefined') {
|
|
modal.data('css-top', parseInt(modal.css('top'), 10))
|
|
.data('offset', this.cache_offset(modal));
|
|
}
|
|
|
|
modal.attr('tabindex','0').attr('aria-hidden','false');
|
|
|
|
this.key_up_on(modal); // PATCH #3: turning on key up capture only when a reveal window is open
|
|
|
|
// Prevent namespace event from triggering twice
|
|
modal.on('open.fndtn.reveal', function(e) {
|
|
if (e.namespace !== 'fndtn.reveal') return;
|
|
});
|
|
|
|
modal.on('open.fndtn.reveal').trigger('open.fndtn.reveal');
|
|
|
|
if (open_modal.length < 1) {
|
|
this.toggle_bg(modal, true);
|
|
}
|
|
|
|
if (typeof ajax_settings === 'string') {
|
|
ajax_settings = {
|
|
url : ajax_settings
|
|
};
|
|
}
|
|
|
|
if (typeof ajax_settings === 'undefined' || !ajax_settings.url) {
|
|
if (open_modal.length > 0) {
|
|
if (settings.multiple_opened) {
|
|
self.to_back(open_modal);
|
|
} else {
|
|
self.hide(open_modal, settings.css.close);
|
|
}
|
|
}
|
|
|
|
this.show(modal, settings.css.open);
|
|
} else {
|
|
var old_success = typeof ajax_settings.success !== 'undefined' ? ajax_settings.success : null;
|
|
$.extend(ajax_settings, {
|
|
success : function (data, textStatus, jqXHR) {
|
|
if ( $.isFunction(old_success) ) {
|
|
var result = old_success(data, textStatus, jqXHR);
|
|
if (typeof result == 'string') {
|
|
data = result;
|
|
}
|
|
}
|
|
|
|
if (typeof options !== 'undefined' && typeof options.replaceContentSel !== 'undefined') {
|
|
modal.find(options.replaceContentSel).html(data);
|
|
} else {
|
|
modal.html(data);
|
|
}
|
|
|
|
self.S(modal).foundation('section', 'reflow');
|
|
self.S(modal).children().foundation();
|
|
|
|
if (open_modal.length > 0) {
|
|
if (settings.multiple_opened) {
|
|
self.to_back(open_modal);
|
|
} else {
|
|
self.hide(open_modal, settings.css.close);
|
|
}
|
|
}
|
|
self.show(modal, settings.css.open);
|
|
}
|
|
});
|
|
|
|
// check for if user initalized with error callback
|
|
if (settings.on_ajax_error !== $.noop) {
|
|
$.extend(ajax_settings, {
|
|
error : settings.on_ajax_error
|
|
});
|
|
}
|
|
|
|
$.ajax(ajax_settings);
|
|
}
|
|
}
|
|
self.S(window).trigger('resize');
|
|
},
|
|
|
|
close : function (modal) {
|
|
var modal = modal && modal.length ? modal : this.S(this.scope),
|
|
open_modals = this.S('[' + this.attr_name() + '].open'),
|
|
settings = modal.data(this.attr_name(true) + '-init') || this.settings,
|
|
self = this;
|
|
|
|
if (open_modals.length > 0) {
|
|
|
|
modal.removeAttr('tabindex','0').attr('aria-hidden','true');
|
|
|
|
this.locked = true;
|
|
this.key_up_off(modal); // PATCH #3: turning on key up capture only when a reveal window is open
|
|
|
|
modal.trigger('close.fndtn.reveal');
|
|
|
|
if ((settings.multiple_opened && open_modals.length === 1) || !settings.multiple_opened || modal.length > 1) {
|
|
self.toggle_bg(modal, false);
|
|
self.to_front(modal);
|
|
}
|
|
|
|
if (settings.multiple_opened) {
|
|
self.hide(modal, settings.css.close, settings);
|
|
self.to_front($($.makeArray(open_modals).reverse()[1]));
|
|
} else {
|
|
self.hide(open_modals, settings.css.close, settings);
|
|
}
|
|
}
|
|
},
|
|
|
|
close_targets : function () {
|
|
var base = '.' + this.settings.dismiss_modal_class;
|
|
|
|
if (this.settings.close_on_background_click) {
|
|
return base + ', .' + this.settings.bg_class;
|
|
}
|
|
|
|
return base;
|
|
},
|
|
|
|
toggle_bg : function (modal, state) {
|
|
if (this.S('.' + this.settings.bg_class).length === 0) {
|
|
this.settings.bg = $('<div />', {'class': this.settings.bg_class})
|
|
.appendTo('body').hide();
|
|
}
|
|
|
|
var visible = this.settings.bg.filter(':visible').length > 0;
|
|
if ( state != visible ) {
|
|
if ( state == undefined ? visible : !state ) {
|
|
this.hide(this.settings.bg);
|
|
} else {
|
|
this.show(this.settings.bg);
|
|
}
|
|
}
|
|
},
|
|
|
|
show : function (el, css) {
|
|
// is modal
|
|
if (css) {
|
|
var settings = el.data(this.attr_name(true) + '-init') || this.settings,
|
|
root_element = settings.root_element,
|
|
context = this;
|
|
|
|
if (el.parent(root_element).length === 0) {
|
|
var placeholder = el.wrap('<div style="display: none;" />').parent();
|
|
|
|
el.on('closed.fndtn.reveal.wrapped', function () {
|
|
el.detach().appendTo(placeholder);
|
|
el.unwrap().unbind('closed.fndtn.reveal.wrapped');
|
|
});
|
|
|
|
el.detach().appendTo(root_element);
|
|
}
|
|
|
|
var animData = getAnimationData(settings.animation);
|
|
if (!animData.animate) {
|
|
this.locked = false;
|
|
}
|
|
if (animData.pop) {
|
|
css.top = $(window).scrollTop() - el.data('offset') + 'px';
|
|
var end_css = {
|
|
top: $(window).scrollTop() + el.data('css-top') + 'px',
|
|
opacity: 1
|
|
};
|
|
|
|
return setTimeout(function () {
|
|
return el
|
|
.css(css)
|
|
.animate(end_css, settings.animation_speed, 'linear', function () {
|
|
context.locked = false;
|
|
el.trigger('opened.fndtn.reveal');
|
|
})
|
|
.addClass('open');
|
|
}, settings.animation_speed / 2);
|
|
}
|
|
|
|
if (animData.fade) {
|
|
css.top = $(window).scrollTop() + el.data('css-top') + 'px';
|
|
var end_css = {opacity: 1};
|
|
|
|
return setTimeout(function () {
|
|
return el
|
|
.css(css)
|
|
.animate(end_css, settings.animation_speed, 'linear', function () {
|
|
context.locked = false;
|
|
el.trigger('opened.fndtn.reveal');
|
|
})
|
|
.addClass('open');
|
|
}, settings.animation_speed / 2);
|
|
}
|
|
|
|
return el.css(css).show().css({opacity : 1}).addClass('open').trigger('opened.fndtn.reveal');
|
|
}
|
|
|
|
var settings = this.settings;
|
|
|
|
// should we animate the background?
|
|
if (getAnimationData(settings.animation).fade) {
|
|
return el.fadeIn(settings.animation_speed / 2);
|
|
}
|
|
|
|
this.locked = false;
|
|
|
|
return el.show();
|
|
},
|
|
|
|
to_back : function(el) {
|
|
el.addClass('toback');
|
|
},
|
|
|
|
to_front : function(el) {
|
|
el.removeClass('toback');
|
|
},
|
|
|
|
hide : function (el, css) {
|
|
// is modal
|
|
if (css) {
|
|
var settings = el.data(this.attr_name(true) + '-init'),
|
|
context = this;
|
|
settings = settings || this.settings;
|
|
|
|
var animData = getAnimationData(settings.animation);
|
|
if (!animData.animate) {
|
|
this.locked = false;
|
|
}
|
|
if (animData.pop) {
|
|
var end_css = {
|
|
top: - $(window).scrollTop() - el.data('offset') + 'px',
|
|
opacity: 0
|
|
};
|
|
|
|
return setTimeout(function () {
|
|
return el
|
|
.animate(end_css, settings.animation_speed, 'linear', function () {
|
|
context.locked = false;
|
|
el.css(css).trigger('closed.fndtn.reveal');
|
|
})
|
|
.removeClass('open');
|
|
}, settings.animation_speed / 2);
|
|
}
|
|
|
|
if (animData.fade) {
|
|
var end_css = {opacity : 0};
|
|
|
|
return setTimeout(function () {
|
|
return el
|
|
.animate(end_css, settings.animation_speed, 'linear', function () {
|
|
context.locked = false;
|
|
el.css(css).trigger('closed.fndtn.reveal');
|
|
})
|
|
.removeClass('open');
|
|
}, settings.animation_speed / 2);
|
|
}
|
|
|
|
return el.hide().css(css).removeClass('open').trigger('closed.fndtn.reveal');
|
|
}
|
|
|
|
var settings = this.settings;
|
|
|
|
// should we animate the background?
|
|
if (getAnimationData(settings.animation).fade) {
|
|
return el.fadeOut(settings.animation_speed / 2);
|
|
}
|
|
|
|
return el.hide();
|
|
},
|
|
|
|
close_video : function (e) {
|
|
var video = $('.flex-video', e.target),
|
|
iframe = $('iframe', video);
|
|
|
|
if (iframe.length > 0) {
|
|
iframe.attr('data-src', iframe[0].src);
|
|
iframe.attr('src', iframe.attr('src'));
|
|
video.hide();
|
|
}
|
|
},
|
|
|
|
open_video : function (e) {
|
|
var video = $('.flex-video', e.target),
|
|
iframe = video.find('iframe');
|
|
|
|
if (iframe.length > 0) {
|
|
var data_src = iframe.attr('data-src');
|
|
if (typeof data_src === 'string') {
|
|
iframe[0].src = iframe.attr('data-src');
|
|
} else {
|
|
var src = iframe[0].src;
|
|
iframe[0].src = undefined;
|
|
iframe[0].src = src;
|
|
}
|
|
video.show();
|
|
}
|
|
},
|
|
|
|
data_attr : function (str) {
|
|
if (this.namespace.length > 0) {
|
|
return this.namespace + '-' + str;
|
|
}
|
|
|
|
return str;
|
|
},
|
|
|
|
cache_offset : function (modal) {
|
|
var offset = modal.show().height() + parseInt(modal.css('top'), 10) + modal.scrollY;
|
|
|
|
modal.hide();
|
|
|
|
return offset;
|
|
},
|
|
|
|
off : function () {
|
|
$(this.scope).off('.fndtn.reveal');
|
|
},
|
|
|
|
reflow : function () {}
|
|
};
|
|
|
|
/*
|
|
* getAnimationData('popAndFade') // {animate: true, pop: true, fade: true}
|
|
* getAnimationData('fade') // {animate: true, pop: false, fade: true}
|
|
* getAnimationData('pop') // {animate: true, pop: true, fade: false}
|
|
* getAnimationData('foo') // {animate: false, pop: false, fade: false}
|
|
* getAnimationData(null) // {animate: false, pop: false, fade: false}
|
|
*/
|
|
function getAnimationData(str) {
|
|
var fade = /fade/i.test(str);
|
|
var pop = /pop/i.test(str);
|
|
return {
|
|
animate : fade || pop,
|
|
pop : pop,
|
|
fade : fade
|
|
};
|
|
}
|
|
}(jQuery, window, window.document));
|
|
;(function ($, window, document, undefined) {
|
|
'use strict';
|
|
|
|
Foundation.libs.interchange = {
|
|
name : 'interchange',
|
|
|
|
version : '5.5.2',
|
|
|
|
cache : {},
|
|
|
|
images_loaded : false,
|
|
nodes_loaded : false,
|
|
|
|
settings : {
|
|
load_attr : 'interchange',
|
|
|
|
named_queries : {
|
|
'default' : 'only screen',
|
|
'small' : Foundation.media_queries['small'],
|
|
'small-only' : Foundation.media_queries['small-only'],
|
|
'medium' : Foundation.media_queries['medium'],
|
|
'medium-only' : Foundation.media_queries['medium-only'],
|
|
'large' : Foundation.media_queries['large'],
|
|
'large-only' : Foundation.media_queries['large-only'],
|
|
'xlarge' : Foundation.media_queries['xlarge'],
|
|
'xlarge-only' : Foundation.media_queries['xlarge-only'],
|
|
'xxlarge' : Foundation.media_queries['xxlarge'],
|
|
'landscape' : 'only screen and (orientation: landscape)',
|
|
'portrait' : 'only screen and (orientation: portrait)',
|
|
'retina' : 'only screen and (-webkit-min-device-pixel-ratio: 2),' +
|
|
'only screen and (min--moz-device-pixel-ratio: 2),' +
|
|
'only screen and (-o-min-device-pixel-ratio: 2/1),' +
|
|
'only screen and (min-device-pixel-ratio: 2),' +
|
|
'only screen and (min-resolution: 192dpi),' +
|
|
'only screen and (min-resolution: 2dppx)'
|
|
},
|
|
|
|
directives : {
|
|
replace : function (el, path, trigger) {
|
|
// The trigger argument, if called within the directive, fires
|
|
// an event named after the directive on the element, passing
|
|
// any parameters along to the event that you pass to trigger.
|
|
//
|
|
// ex. trigger(), trigger([a, b, c]), or trigger(a, b, c)
|
|
//
|
|
// This allows you to bind a callback like so:
|
|
// $('#interchangeContainer').on('replace', function (e, a, b, c) {
|
|
// console.log($(this).html(), a, b, c);
|
|
// });
|
|
|
|
if (el !== null && /IMG/.test(el[0].nodeName)) {
|
|
var orig_path = el[0].src;
|
|
|
|
if (new RegExp(path, 'i').test(orig_path)) {
|
|
return;
|
|
}
|
|
|
|
el.attr("src", path);
|
|
|
|
return trigger(el[0].src);
|
|
}
|
|
var last_path = el.data(this.data_attr + '-last-path'),
|
|
self = this;
|
|
|
|
if (last_path == path) {
|
|
return;
|
|
}
|
|
|
|
if (/\.(gif|jpg|jpeg|tiff|png)([?#].*)?/i.test(path)) {
|
|
$(el).css('background-image', 'url(' + path + ')');
|
|
el.data('interchange-last-path', path);
|
|
return trigger(path);
|
|
}
|
|
|
|
return $.get(path, function (response) {
|
|
el.html(response);
|
|
el.data(self.data_attr + '-last-path', path);
|
|
trigger();
|
|
});
|
|
|
|
}
|
|
}
|
|
},
|
|
|
|
init : function (scope, method, options) {
|
|
Foundation.inherit(this, 'throttle random_str');
|
|
|
|
this.data_attr = this.set_data_attr();
|
|
$.extend(true, this.settings, method, options);
|
|
this.bindings(method, options);
|
|
this.reflow();
|
|
},
|
|
|
|
get_media_hash : function () {
|
|
var mediaHash = '';
|
|
for (var queryName in this.settings.named_queries ) {
|
|
mediaHash += matchMedia(this.settings.named_queries[queryName]).matches.toString();
|
|
}
|
|
return mediaHash;
|
|
},
|
|
|
|
events : function () {
|
|
var self = this, prevMediaHash;
|
|
|
|
$(window)
|
|
.off('.interchange')
|
|
.on('resize.fndtn.interchange', self.throttle(function () {
|
|
var currMediaHash = self.get_media_hash();
|
|
if (currMediaHash !== prevMediaHash) {
|
|
self.resize();
|
|
}
|
|
prevMediaHash = currMediaHash;
|
|
}, 50));
|
|
|
|
return this;
|
|
},
|
|
|
|
resize : function () {
|
|
var cache = this.cache;
|
|
|
|
if (!this.images_loaded || !this.nodes_loaded) {
|
|
setTimeout($.proxy(this.resize, this), 50);
|
|
return;
|
|
}
|
|
|
|
for (var uuid in cache) {
|
|
if (cache.hasOwnProperty(uuid)) {
|
|
var passed = this.results(uuid, cache[uuid]);
|
|
if (passed) {
|
|
this.settings.directives[passed
|
|
.scenario[1]].call(this, passed.el, passed.scenario[0], (function (passed) {
|
|
if (arguments[0] instanceof Array) {
|
|
var args = arguments[0];
|
|
} else {
|
|
var args = Array.prototype.slice.call(arguments, 0);
|
|
}
|
|
|
|
return function() {
|
|
passed.el.trigger(passed.scenario[1], args);
|
|
}
|
|
}(passed)));
|
|
}
|
|
}
|
|
}
|
|
|
|
},
|
|
|
|
results : function (uuid, scenarios) {
|
|
var count = scenarios.length;
|
|
|
|
if (count > 0) {
|
|
var el = this.S('[' + this.add_namespace('data-uuid') + '="' + uuid + '"]');
|
|
|
|
while (count--) {
|
|
var mq, rule = scenarios[count][2];
|
|
if (this.settings.named_queries.hasOwnProperty(rule)) {
|
|
mq = matchMedia(this.settings.named_queries[rule]);
|
|
} else {
|
|
mq = matchMedia(rule);
|
|
}
|
|
if (mq.matches) {
|
|
return {el : el, scenario : scenarios[count]};
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
},
|
|
|
|
load : function (type, force_update) {
|
|
if (typeof this['cached_' + type] === 'undefined' || force_update) {
|
|
this['update_' + type]();
|
|
}
|
|
|
|
return this['cached_' + type];
|
|
},
|
|
|
|
update_images : function () {
|
|
var images = this.S('img[' + this.data_attr + ']'),
|
|
count = images.length,
|
|
i = count,
|
|
loaded_count = 0,
|
|
data_attr = this.data_attr;
|
|
|
|
this.cache = {};
|
|
this.cached_images = [];
|
|
this.images_loaded = (count === 0);
|
|
|
|
while (i--) {
|
|
loaded_count++;
|
|
if (images[i]) {
|
|
var str = images[i].getAttribute(data_attr) || '';
|
|
|
|
if (str.length > 0) {
|
|
this.cached_images.push(images[i]);
|
|
}
|
|
}
|
|
|
|
if (loaded_count === count) {
|
|
this.images_loaded = true;
|
|
this.enhance('images');
|
|
}
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
update_nodes : function () {
|
|
var nodes = this.S('[' + this.data_attr + ']').not('img'),
|
|
count = nodes.length,
|
|
i = count,
|
|
loaded_count = 0,
|
|
data_attr = this.data_attr;
|
|
|
|
this.cached_nodes = [];
|
|
this.nodes_loaded = (count === 0);
|
|
|
|
while (i--) {
|
|
loaded_count++;
|
|
var str = nodes[i].getAttribute(data_attr) || '';
|
|
|
|
if (str.length > 0) {
|
|
this.cached_nodes.push(nodes[i]);
|
|
}
|
|
|
|
if (loaded_count === count) {
|
|
this.nodes_loaded = true;
|
|
this.enhance('nodes');
|
|
}
|
|
}
|
|
|
|
return this;
|
|
},
|
|
|
|
enhance : function (type) {
|
|
var i = this['cached_' + type].length;
|
|
|
|
while (i--) {
|
|
this.object($(this['cached_' + type][i]));
|
|
}
|
|
|
|
return $(window).trigger('resize.fndtn.interchange');
|
|
},
|
|
|
|
convert_directive : function (directive) {
|
|
|
|
var trimmed = this.trim(directive);
|
|
|
|
if (trimmed.length > 0) {
|
|
return trimmed;
|
|
}
|
|
|
|
return 'replace';
|
|
},
|
|
|
|
parse_scenario : function (scenario) {
|
|
// This logic had to be made more complex since some users were using commas in the url path
|
|
// So we cannot simply just split on a comma
|
|
|
|
var directive_match = scenario[0].match(/(.+),\s*(\w+)\s*$/),
|
|
// getting the mq has gotten a bit complicated since we started accounting for several use cases
|
|
// of URLs. For now we'll continue to match these scenarios, but we may consider having these scenarios
|
|
// as nested objects or arrays in F6.
|
|
// regex: match everything before close parenthesis for mq
|
|
media_query = scenario[1].match(/(.*)\)/);
|
|
|
|
if (directive_match) {
|
|
var path = directive_match[1],
|
|
directive = directive_match[2];
|
|
|
|
} else {
|
|
var cached_split = scenario[0].split(/,\s*$/),
|
|
path = cached_split[0],
|
|
directive = '';
|
|
}
|
|
|
|
return [this.trim(path), this.convert_directive(directive), this.trim(media_query[1])];
|
|
},
|
|
|
|
object : function (el) {
|
|
var raw_arr = this.parse_data_attr(el),
|
|
scenarios = [],
|
|
i = raw_arr.length;
|
|
|
|
if (i > 0) {
|
|
while (i--) {
|
|
// split array between comma delimited content and mq
|
|
// regex: comma, optional space, open parenthesis
|
|
var scenario = raw_arr[i].split(/,\s?\(/);
|
|
|
|
if (scenario.length > 1) {
|
|
var params = this.parse_scenario(scenario);
|
|
scenarios.push(params);
|
|
}
|
|
}
|
|
}
|
|
|
|
return this.store(el, scenarios);
|
|
},
|
|
|
|
store : function (el, scenarios) {
|
|
var uuid = this.random_str(),
|
|
current_uuid = el.data(this.add_namespace('uuid', true));
|
|
|
|
if (this.cache[current_uuid]) {
|
|
return this.cache[current_uuid];
|
|
}
|
|
|
|
el.attr(this.add_namespace('data-uuid'), uuid);
|
|
return this.cache[uuid] = scenarios;
|
|
},
|
|
|
|
trim : function (str) {
|
|
|
|
if (typeof str === 'string') {
|
|
return $.trim(str);
|
|
}
|
|
|
|
return str;
|
|
},
|
|
|
|
set_data_attr : function (init) {
|
|
if (init) {
|
|
if (this.namespace.length > 0) {
|
|
return this.namespace + '-' + this.settings.load_attr;
|
|
}
|
|
|
|
return this.settings.load_attr;
|
|
}
|
|
|
|
if (this.namespace.length > 0) {
|
|
return 'data-' + this.namespace + '-' + this.settings.load_attr;
|
|
}
|
|
|
|
return 'data-' + this.settings.load_attr;
|
|
},
|
|
|
|
parse_data_attr : function (el) {
|
|
var raw = el.attr(this.attr_name()).split(/\[(.*?)\]/),
|
|
i = raw.length,
|
|
output = [];
|
|
|
|
while (i--) {
|
|
if (raw[i].replace(/[\W\d]+/, '').length > 4) {
|
|
output.push(raw[i]);
|
|
}
|
|
}
|
|
|
|
return output;
|
|
},
|
|
|
|
reflow : function () {
|
|
this.load('images', true);
|
|
this.load('nodes', true);
|
|
}
|
|
|
|
};
|
|
|
|
}(jQuery, window, window.document));
|