| /* |
| * Foundation Responsive Library |
| * http://foundation.zurb.com |
| * Copyright 2015, 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 head = $('head'); |
| head.prepend($.map(class_array, function (class_name) { |
| if (head.has('.' + class_name).length === 0) { |
| return '<meta class="' + class_name + '" />'; |
| } |
| })); |
| }; |
| |
| 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; |
| } |
| |
| function MediaQuery(selector) { |
| this.selector = selector; |
| this.query = ''; |
| } |
| |
| MediaQuery.prototype.toString = function () { |
| return this.query || (this.query = S(this.selector).css('font-family').replace(/^[\/\\'"]+|(;\s?})+|[\/\\'"]+$/g, '')); |
| }; |
| |
| window.Foundation = { |
| name : 'Foundation', |
| |
| version : '5.5.3', |
| |
| media_queries : { |
| 'small' : new MediaQuery('.foundation-mq-small'), |
| 'small-only' : new MediaQuery('.foundation-mq-small-only'), |
| 'medium' : new MediaQuery('.foundation-mq-medium'), |
| 'medium-only' : new MediaQuery('.foundation-mq-medium-only'), |
| 'large' : new MediaQuery('.foundation-mq-large'), |
| 'large-only' : new MediaQuery('.foundation-mq-large-only'), |
| 'xlarge' : new MediaQuery('.foundation-mq-xlarge'), |
| 'xlarge-only' : new MediaQuery('.foundation-mq-xlarge-only'), |
| 'xxlarge' : new MediaQuery('.foundation-mq-xxlarge') |
| }, |
| |
| 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.topbar = { |
| name : 'topbar', |
| |
| version : '5.5.3', |
| |
| settings : { |
| index : 0, |
| start_offset : 0, |
| sticky_class : 'sticky', |
| custom_back_text : true, |
| back_text : 'Back', |
| mobile_show_parent_link : true, |
| is_hover : true, |
| scrolltop : true, // jump to top when sticky nav menu toggle is clicked |
| sticky_on : 'all', |
| dropdown_autoclose: true |
| }, |
| |
| init : function (section, method, options) { |
| Foundation.inherit(this, 'add_custom_rule register_media throttle'); |
| var self = this; |
| |
| self.register_media('topbar', 'foundation-mq-topbar'); |
| |
| this.bindings(method, options); |
| |
| self.S('[' + this.attr_name() + ']', this.scope).each(function () { |
| var topbar = $(this), |
| settings = topbar.data(self.attr_name(true) + '-init'), |
| section = self.S('section, .top-bar-section', this); |
| topbar.data('index', 0); |
| var topbarContainer = topbar.parent(); |
| if (topbarContainer.hasClass('fixed') || self.is_sticky(topbar, topbarContainer, settings) ) { |
| self.settings.sticky_class = settings.sticky_class; |
| self.settings.sticky_topbar = topbar; |
| topbar.data('height', topbarContainer.outerHeight()); |
| topbar.data('stickyoffset', topbarContainer.offset().top); |
| } else { |
| topbar.data('height', topbar.outerHeight()); |
| } |
| |
| if (!settings.assembled) { |
| self.assemble(topbar); |
| } |
| |
| if (settings.is_hover) { |
| self.S('.has-dropdown', topbar).addClass('not-click'); |
| } else { |
| self.S('.has-dropdown', topbar).removeClass('not-click'); |
| } |
| |
| // Pad body when sticky (scrolled) or fixed. |
| self.add_custom_rule('.f-topbar-fixed { padding-top: ' + topbar.data('height') + 'px }'); |
| |
| if (topbarContainer.hasClass('fixed')) { |
| self.S('body').addClass('f-topbar-fixed'); |
| } |
| }); |
| |
| }, |
| |
| is_sticky : function (topbar, topbarContainer, settings) { |
| var sticky = topbarContainer.hasClass(settings.sticky_class); |
| var smallMatch = matchMedia(Foundation.media_queries.small).matches; |
| var medMatch = matchMedia(Foundation.media_queries.medium).matches; |
| var lrgMatch = matchMedia(Foundation.media_queries.large).matches; |
| |
| if (sticky && settings.sticky_on === 'all') { |
| return true; |
| } |
| if (sticky && this.small() && settings.sticky_on.indexOf('small') !== -1) { |
| if (smallMatch && !medMatch && !lrgMatch) { return true; } |
| } |
| if (sticky && this.medium() && settings.sticky_on.indexOf('medium') !== -1) { |
| if (smallMatch && medMatch && !lrgMatch) { return true; } |
| } |
| if (sticky && this.large() && settings.sticky_on.indexOf('large') !== -1) { |
| if (smallMatch && medMatch && lrgMatch) { return true; } |
| } |
| |
| return false; |
| }, |
| |
| toggle : function (toggleEl) { |
| var self = this, |
| topbar; |
| |
| if (toggleEl) { |
| topbar = self.S(toggleEl).closest('[' + this.attr_name() + ']'); |
| } else { |
| topbar = self.S('[' + this.attr_name() + ']'); |
| } |
| |
| var settings = topbar.data(this.attr_name(true) + '-init'); |
| |
| var section = self.S('section, .top-bar-section', topbar); |
| |
| if (self.breakpoint()) { |
| if (!self.rtl) { |
| section.css({left : '0%'}); |
| $('>.name', section).css({left : '100%'}); |
| } else { |
| section.css({right : '0%'}); |
| $('>.name', section).css({right : '100%'}); |
| } |
| |
| self.S('li.moved', section).removeClass('moved'); |
| topbar.data('index', 0); |
| |
| topbar |
| .toggleClass('expanded') |
| .css('height', ''); |
| } |
| |
| if (settings.scrolltop) { |
| if (!topbar.hasClass('expanded')) { |
| if (topbar.hasClass('fixed')) { |
| topbar.parent().addClass('fixed'); |
| topbar.removeClass('fixed'); |
| self.S('body').addClass('f-topbar-fixed'); |
| } |
| } else if (topbar.parent().hasClass('fixed')) { |
| if (settings.scrolltop) { |
| topbar.parent().removeClass('fixed'); |
| topbar.addClass('fixed'); |
| self.S('body').removeClass('f-topbar-fixed'); |
| |
| window.scrollTo(0, 0); |
| } else { |
| topbar.parent().removeClass('expanded'); |
| } |
| } |
| } else { |
| if (self.is_sticky(topbar, topbar.parent(), settings)) { |
| topbar.parent().addClass('fixed'); |
| } |
| |
| if (topbar.parent().hasClass('fixed')) { |
| if (!topbar.hasClass('expanded')) { |
| topbar.removeClass('fixed'); |
| topbar.parent().removeClass('expanded'); |
| self.update_sticky_positioning(); |
| } else { |
| topbar.addClass('fixed'); |
| topbar.parent().addClass('expanded'); |
| self.S('body').addClass('f-topbar-fixed'); |
| } |
| } |
| } |
| }, |
| |
| timer : null, |
| |
| events : function (bar) { |
| var self = this, |
| S = this.S; |
| |
| S(this.scope) |
| .off('.topbar') |
| .on('click.fndtn.topbar', '[' + this.attr_name() + '] .toggle-topbar', function (e) { |
| e.preventDefault(); |
| self.toggle(this); |
| }) |
| .on('click.fndtn.topbar contextmenu.fndtn.topbar', '.top-bar .top-bar-section li a[href^="#"],[' + this.attr_name() + '] .top-bar-section li a[href^="#"]', function (e) { |
| var li = $(this).closest('li'), |
| topbar = li.closest('[' + self.attr_name() + ']'), |
| settings = topbar.data(self.attr_name(true) + '-init'); |
| |
| if (settings.dropdown_autoclose && settings.is_hover) { |
| var hoverLi = $(this).closest('.hover'); |
| hoverLi.removeClass('hover'); |
| } |
| if (self.breakpoint() && !li.hasClass('back') && !li.hasClass('has-dropdown')) { |
| self.toggle(); |
| } |
| |
| }) |
| .on('click.fndtn.topbar', '[' + this.attr_name() + '] li.has-dropdown', function (e) { |
| var li = S(this), |
| target = S(e.target), |
| topbar = li.closest('[' + self.attr_name() + ']'), |
| settings = topbar.data(self.attr_name(true) + '-init'); |
| |
| if (target.data('revealId')) { |
| self.toggle(); |
| return; |
| } |
| |
| if (self.breakpoint()) { |
| return; |
| } |
| |
| if (settings.is_hover && !Modernizr.touch) { |
| return; |
| } |
| |
| e.stopImmediatePropagation(); |
| |
| if (li.hasClass('hover')) { |
| li |
| .removeClass('hover') |
| .find('li') |
| .removeClass('hover'); |
| |
| li.parents('li.hover') |
| .removeClass('hover'); |
| } else { |
| li.addClass('hover'); |
| |
| $(li).siblings().removeClass('hover'); |
| |
| if (target[0].nodeName === 'A' && target.parent().hasClass('has-dropdown')) { |
| e.preventDefault(); |
| } |
| } |
| }) |
| .on('click.fndtn.topbar', '[' + this.attr_name() + '] .has-dropdown>a', function (e) { |
| if (self.breakpoint()) { |
| |
| e.preventDefault(); |
| |
| var $this = S(this), |
| topbar = $this.closest('[' + self.attr_name() + ']'), |
| section = topbar.find('section, .top-bar-section'), |
| dropdownHeight = $this.next('.dropdown').outerHeight(), |
| $selectedLi = $this.closest('li'); |
| |
| topbar.data('index', topbar.data('index') + 1); |
| $selectedLi.addClass('moved'); |
| |
| if (!self.rtl) { |
| section.css({left : -(100 * topbar.data('index')) + '%'}); |
| section.find('>.name').css({left : 100 * topbar.data('index') + '%'}); |
| } else { |
| section.css({right : -(100 * topbar.data('index')) + '%'}); |
| section.find('>.name').css({right : 100 * topbar.data('index') + '%'}); |
| } |
| |
| topbar.css('height', $this.siblings('ul').outerHeight(true) + topbar.data('height')); |
| } |
| }); |
| |
| S(window).off('.topbar').on('resize.fndtn.topbar', self.throttle(function () { |
| self.resize.call(self); |
| }, 50)).trigger('resize.fndtn.topbar').load(function () { |
| // Ensure that the offset is calculated after all of the pages resources have loaded |
| S(this).trigger('resize.fndtn.topbar'); |
| }); |
| |
| S('body').off('.topbar').on('click.fndtn.topbar', function (e) { |
| var parent = S(e.target).closest('li').closest('li.hover'); |
| |
| if (parent.length > 0) { |
| return; |
| } |
| |
| S('[' + self.attr_name() + '] li.hover').removeClass('hover'); |
| }); |
| |
| // Go up a level on Click |
| S(this.scope).on('click.fndtn.topbar', '[' + this.attr_name() + '] .has-dropdown .back', function (e) { |
| e.preventDefault(); |
| |
| var $this = S(this), |
| topbar = $this.closest('[' + self.attr_name() + ']'), |
| section = topbar.find('section, .top-bar-section'), |
| settings = topbar.data(self.attr_name(true) + '-init'), |
| $movedLi = $this.closest('li.moved'), |
| $previousLevelUl = $movedLi.parent(); |
| |
| topbar.data('index', topbar.data('index') - 1); |
| |
| if (!self.rtl) { |
| section.css({left : -(100 * topbar.data('index')) + '%'}); |
| section.find('>.name').css({left : 100 * topbar.data('index') + '%'}); |
| } else { |
| section.css({right : -(100 * topbar.data('index')) + '%'}); |
| section.find('>.name').css({right : 100 * topbar.data('index') + '%'}); |
| } |
| |
| if (topbar.data('index') === 0) { |
| topbar.css('height', ''); |
| } else { |
| topbar.css('height', $previousLevelUl.outerHeight(true) + topbar.data('height')); |
| } |
| |
| setTimeout(function () { |
| $movedLi.removeClass('moved'); |
| }, 300); |
| }); |
| |
| // Show dropdown menus when their items are focused |
| S(this.scope).find('.dropdown a') |
| .focus(function () { |
| $(this).parents('.has-dropdown').addClass('hover'); |
| }) |
| .blur(function () { |
| $(this).parents('.has-dropdown').removeClass('hover'); |
| }); |
| }, |
| |
| resize : function () { |
| var self = this; |
| self.S('[' + this.attr_name() + ']').each(function () { |
| var topbar = self.S(this), |
| settings = topbar.data(self.attr_name(true) + '-init'); |
| |
| var stickyContainer = topbar.parent('.' + self.settings.sticky_class); |
| var stickyOffset; |
| |
| if (!self.breakpoint()) { |
| var doToggle = topbar.hasClass('expanded'); |
| topbar |
| .css('height', '') |
| .removeClass('expanded') |
| .find('li') |
| .removeClass('hover'); |
| |
| if (doToggle) { |
| self.toggle(topbar); |
| } |
| } |
| |
| if (self.is_sticky(topbar, stickyContainer, settings)) { |
| if (stickyContainer.hasClass('fixed')) { |
| // Remove the fixed to allow for correct calculation of the offset. |
| stickyContainer.removeClass('fixed'); |
| |
| stickyOffset = stickyContainer.offset().top; |
| if (self.S(document.body).hasClass('f-topbar-fixed')) { |
| stickyOffset -= topbar.data('height'); |
| } |
| |
| topbar.data('stickyoffset', stickyOffset); |
| stickyContainer.addClass('fixed'); |
| } else { |
| stickyOffset = stickyContainer.offset().top; |
| topbar.data('stickyoffset', stickyOffset); |
| } |
| } |
| |
| }); |
| }, |
| |
| breakpoint : function () { |
| return !matchMedia(Foundation.media_queries['topbar']).matches; |
| }, |
| |
| small : function () { |
| return matchMedia(Foundation.media_queries['small']).matches; |
| }, |
| |
| medium : function () { |
| return matchMedia(Foundation.media_queries['medium']).matches; |
| }, |
| |
| large : function () { |
| return matchMedia(Foundation.media_queries['large']).matches; |
| }, |
| |
| assemble : function (topbar) { |
| var self = this, |
| settings = topbar.data(this.attr_name(true) + '-init'), |
| section = self.S('section, .top-bar-section', topbar); |
| |
| // Pull element out of the DOM for manipulation |
| section.detach(); |
| |
| self.S('.has-dropdown>a', section).each(function () { |
| var $link = self.S(this), |
| $dropdown = $link.siblings('.dropdown'), |
| url = $link.attr('href'), |
| $titleLi; |
| |
| if (!$dropdown.find('.title.back').length) { |
| |
| if (settings.mobile_show_parent_link == true && url) { |
| $titleLi = $('<li class="title back js-generated"><h5><a href="javascript:void(0)"></a></h5></li><li class="parent-link hide-for-medium-up"><a class="parent-link js-generated" href="' + url + '">' + $link.html() +'</a></li>'); |
| } else { |
| $titleLi = $('<li class="title back js-generated"><h5><a href="javascript:void(0)"></a></h5>'); |
| } |
| |
| // Copy link to subnav |
| if (settings.custom_back_text == true) { |
| $('h5>a', $titleLi).html(settings.back_text); |
| } else { |
| $('h5>a', $titleLi).html('« ' + $link.html()); |
| } |
| $dropdown.prepend($titleLi); |
| } |
| }); |
| |
| // Put element back in the DOM |
| section.appendTo(topbar); |
| |
| // check for sticky |
| this.sticky(); |
| |
| this.assembled(topbar); |
| }, |
| |
| assembled : function (topbar) { |
| topbar.data(this.attr_name(true), $.extend({}, topbar.data(this.attr_name(true)), {assembled : true})); |
| }, |
| |
| height : function (ul) { |
| var total = 0, |
| self = this; |
| |
| $('> li', ul).each(function () { |
| total += self.S(this).outerHeight(true); |
| }); |
| |
| return total; |
| }, |
| |
| sticky : function () { |
| var self = this; |
| |
| this.S(window).on('scroll', function () { |
| self.update_sticky_positioning(); |
| }); |
| }, |
| |
| update_sticky_positioning : function () { |
| var klass = '.' + this.settings.sticky_class, |
| $window = this.S(window), |
| self = this; |
| |
| if (self.settings.sticky_topbar && self.is_sticky(this.settings.sticky_topbar,this.settings.sticky_topbar.parent(), this.settings)) { |
| var distance = this.settings.sticky_topbar.data('stickyoffset') + this.settings.start_offset; |
| if (!self.S(klass).hasClass('expanded')) { |
| if ($window.scrollTop() > (distance)) { |
| if (!self.S(klass).hasClass('fixed')) { |
| self.S(klass).addClass('fixed'); |
| self.S('body').addClass('f-topbar-fixed'); |
| } |
| } else if ($window.scrollTop() <= distance) { |
| if (self.S(klass).hasClass('fixed')) { |
| self.S(klass).removeClass('fixed'); |
| self.S('body').removeClass('f-topbar-fixed'); |
| } |
| } |
| } |
| } |
| }, |
| |
| off : function () { |
| this.S(this.scope).off('.fndtn.topbar'); |
| this.S(window).off('.fndtn.topbar'); |
| }, |
| |
| reflow : function () {} |
| }; |
| }(jQuery, window, window.document)); |
| ;;(function ($, window, document, undefined) { |
| 'use strict'; |
| |
| var openModals = []; |
| |
| Foundation.libs.reveal = { |
| name : 'reveal', |
| |
| version : '5.5.3', |
| |
| 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 !== undefined && 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 |
| }; |
| } |
| |
| var openModal = function() { |
| if(open_modal.length > 0) { |
| if(settings.multiple_opened) { |
| self.to_back(open_modal); |
| } else { |
| self.hide(open_modal, settings.css.close); |
| } |
| } |
| |
| // bl: add the open_modal that isn't already in the background to the openModals array |
| if(settings.multiple_opened) { |
| openModals.push(modal); |
| } |
| |
| self.show(modal, settings.css.open); |
| }; |
| |
| if (typeof ajax_settings === 'undefined' || !ajax_settings.url) { |
| openModal(); |
| } 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(); |
| |
| openModal(); |
| } |
| }); |
| |
| // 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) { |
| var isCurrent = modal.is(':not(.toback)'); |
| self.hide(modal, settings.css.close, settings); |
| if(isCurrent) { |
| // remove the last modal since it is now closed |
| openModals.pop(); |
| } else { |
| // if this isn't the current modal, then find it in the array and remove it |
| openModals = $.grep(openModals, function(elt) { |
| var isThis = elt[0]===modal[0]; |
| if(isThis) { |
| // since it's not currently in the front, put it in the front now that it is hidden |
| // so that if it's re-opened, it won't be .toback |
| self.to_front(modal); |
| } |
| return !isThis; |
| }); |
| } |
| // finally, show the next modal in the stack, if there is one |
| if(openModals.length>0) { |
| self.to_front(openModals[openModals.length - 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); |
| } |
| |
| css.top = $(window).scrollTop() + el.data('css-top') + 'px'; |
| |
| if (animData.fade) { |
| 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)); |
