-
-
Save imemohit/4aa6f0771c7ec61b82e6551e8b337365 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /*! Magnific Popup - v1.1.0 - 2016-02-20 | |
| * http://dimsemenov.com/plugins/magnific-popup/ | |
| * Copyright (c) 2016 Dmitry Semenov; */ | |
| ;(function (factory) { | |
| if (typeof define === 'function' && define.amd) { | |
| // AMD. Register as an anonymous module. | |
| define(['jquery'], factory); | |
| } else if (typeof exports === 'object') { | |
| // Node/CommonJS | |
| factory(require('jquery')); | |
| } else { | |
| // Browser globals | |
| factory(window.jQuery || window.Zepto); | |
| } | |
| }(function($) { | |
| /*>>core*/ | |
| /** | |
| * | |
| * Magnific Popup Core JS file | |
| * | |
| */ | |
| /** | |
| * Private static constants | |
| */ | |
| var CLOSE_EVENT = 'Close', | |
| BEFORE_CLOSE_EVENT = 'BeforeClose', | |
| AFTER_CLOSE_EVENT = 'AfterClose', | |
| BEFORE_APPEND_EVENT = 'BeforeAppend', | |
| MARKUP_PARSE_EVENT = 'MarkupParse', | |
| OPEN_EVENT = 'Open', | |
| CHANGE_EVENT = 'Change', | |
| NS = 'mfp', | |
| EVENT_NS = '.' + NS, | |
| READY_CLASS = 'mfp-ready', | |
| REMOVING_CLASS = 'mfp-removing', | |
| PREVENT_CLOSE_CLASS = 'mfp-prevent-close'; | |
| /** | |
| * Private vars | |
| */ | |
| var mfp, // As we have only one instance of MagnificPopup object, we define it locally to not to use 'this' | |
| MagnificPopup = function(){}, | |
| _isJQ = !!(window.jQuery), | |
| _prevStatus, | |
| _window = $(window), | |
| _body, | |
| _document, | |
| _prevContentType, | |
| _wrapClasses, | |
| _currPopupType; | |
| /** | |
| * Private functions | |
| */ | |
| var _mfpOn = function(name, f) { | |
| mfp.ev.on(NS + name + EVENT_NS, f); | |
| }, | |
| _getEl = function(className, appendTo, html, raw) { | |
| var el = document.createElement('div'); | |
| el.className = 'mfp-'+className; | |
| if(html) { | |
| el.innerHTML = html; | |
| } | |
| if(!raw) { | |
| el = $(el); | |
| if(appendTo) { | |
| el.appendTo(appendTo); | |
| } | |
| } else if(appendTo) { | |
| appendTo.appendChild(el); | |
| } | |
| return el; | |
| }, | |
| _mfpTrigger = function(e, data) { | |
| mfp.ev.triggerHandler(NS + e, data); | |
| if(mfp.st.callbacks) { | |
| // converts "mfpEventName" to "eventName" callback and triggers it if it's present | |
| e = e.charAt(0).toLowerCase() + e.slice(1); | |
| if(mfp.st.callbacks[e]) { | |
| mfp.st.callbacks[e].apply(mfp, $.isArray(data) ? data : [data]); | |
| } | |
| } | |
| }, | |
| _getCloseBtn = function(type) { | |
| if(type !== _currPopupType || !mfp.currTemplate.closeBtn) { | |
| mfp.currTemplate.closeBtn = $( mfp.st.closeMarkup.replace('%title%', mfp.st.tClose ) ); | |
| _currPopupType = type; | |
| } | |
| return mfp.currTemplate.closeBtn; | |
| }, | |
| // Initialize Magnific Popup only when called at least once | |
| _checkInstance = function() { | |
| if(!$.magnificPopup.instance) { | |
| mfp = new MagnificPopup(); | |
| mfp.init(); | |
| $.magnificPopup.instance = mfp; | |
| } | |
| }, | |
| // CSS transition detection, http://stackoverflow.com/questions/7264899/detect-css-transitions-using-javascript-and-without-modernizr | |
| supportsTransitions = function() { | |
| var s = document.createElement('p').style, // 's' for style. better to create an element if body yet to exist | |
| v = ['ms','O','Moz','Webkit']; // 'v' for vendor | |
| if( s['transition'] !== undefined ) { | |
| return true; | |
| } | |
| while( v.length ) { | |
| if( v.pop() + 'Transition' in s ) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }; | |
| /** | |
| * Public functions | |
| */ | |
| MagnificPopup.prototype = { | |
| constructor: MagnificPopup, | |
| /** | |
| * Initializes Magnific Popup plugin. | |
| * This function is triggered only once when $.fn.magnificPopup or $.magnificPopup is executed | |
| */ | |
| init: function() { | |
| var appVersion = navigator.appVersion; | |
| mfp.isIE7 = appVersion.indexOf("MSIE 7.") !== -1; | |
| mfp.isIE8 = appVersion.indexOf("MSIE 8.") !== -1; | |
| mfp.isLowIE = mfp.isIE7 || mfp.isIE8; | |
| mfp.isAndroid = (/android/gi).test(appVersion); | |
| mfp.isIOS = (/iphone|ipad|ipod/gi).test(appVersion); | |
| mfp.supportsTransition = supportsTransitions(); | |
| // We disable fixed positioned lightbox on devices that don't handle it nicely. | |
| // If you know a better way of detecting this - let me know. | |
| mfp.probablyMobile = (mfp.isAndroid || mfp.isIOS || /(Opera Mini)|Kindle|webOS|BlackBerry|(Opera Mobi)|(Windows Phone)|IEMobile/i.test(navigator.userAgent) ); | |
| _document = $(document); | |
| mfp.popupsCache = {}; | |
| }, | |
| /** | |
| * Opens popup | |
| * @param data [description] | |
| */ | |
| open: function(data) { | |
| if(!_body) { | |
| _body = $(document.body); | |
| } | |
| var i; | |
| if(data.isObj === false) { | |
| // convert jQuery collection to array to avoid conflicts later | |
| mfp.items = data.items.toArray(); | |
| mfp.index = 0; | |
| var items = data.items, | |
| item; | |
| for(i = 0; i < items.length; i++) { | |
| item = items[i]; | |
| if(item.parsed) { | |
| item = item.el[0]; | |
| } | |
| if(item === data.el[0]) { | |
| mfp.index = i; | |
| break; | |
| } | |
| } | |
| } else { | |
| mfp.items = $.isArray(data.items) ? data.items : [data.items]; | |
| mfp.index = data.index || 0; | |
| } | |
| // if popup is already opened - we just update the content | |
| if(mfp.isOpen) { | |
| mfp.updateItemHTML(); | |
| return; | |
| } | |
| mfp.types = []; | |
| _wrapClasses = ''; | |
| if(data.mainEl && data.mainEl.length) { | |
| mfp.ev = data.mainEl.eq(0); | |
| } else { | |
| mfp.ev = _document; | |
| } | |
| if(data.key) { | |
| if(!mfp.popupsCache[data.key]) { | |
| mfp.popupsCache[data.key] = {}; | |
| } | |
| mfp.currTemplate = mfp.popupsCache[data.key]; | |
| } else { | |
| mfp.currTemplate = {}; | |
| } | |
| mfp.st = $.extend(true, {}, $.magnificPopup.defaults, data ); | |
| mfp.fixedContentPos = mfp.st.fixedContentPos === 'auto' ? !mfp.probablyMobile : mfp.st.fixedContentPos; | |
| if(mfp.st.modal) { | |
| mfp.st.closeOnContentClick = false; | |
| mfp.st.closeOnBgClick = false; | |
| mfp.st.showCloseBtn = false; | |
| mfp.st.enableEscapeKey = false; | |
| } | |
| // Building markup | |
| // main containers are created only once | |
| if(!mfp.bgOverlay) { | |
| // Dark overlay | |
| mfp.bgOverlay = _getEl('bg').on('click'+EVENT_NS, function() { | |
| mfp.close(); | |
| }); | |
| mfp.wrap = _getEl('wrap').attr('tabindex', -1).on('click'+EVENT_NS, function(e) { | |
| if(mfp._checkIfClose(e.target)) { | |
| mfp.close(); | |
| } | |
| }); | |
| mfp.container = _getEl('container', mfp.wrap); | |
| } | |
| mfp.contentContainer = _getEl('content'); | |
| if(mfp.st.preloader) { | |
| mfp.preloader = _getEl('preloader', mfp.container, mfp.st.tLoading); | |
| } | |
| // Initializing modules | |
| var modules = $.magnificPopup.modules; | |
| for(i = 0; i < modules.length; i++) { | |
| var n = modules[i]; | |
| n = n.charAt(0).toUpperCase() + n.slice(1); | |
| mfp['init'+n].call(mfp); | |
| } | |
| _mfpTrigger('BeforeOpen'); | |
| if(mfp.st.showCloseBtn) { | |
| // Close button | |
| if(!mfp.st.closeBtnInside) { | |
| mfp.wrap.append( _getCloseBtn() ); | |
| } else { | |
| _mfpOn(MARKUP_PARSE_EVENT, function(e, template, values, item) { | |
| values.close_replaceWith = _getCloseBtn(item.type); | |
| }); | |
| _wrapClasses += ' mfp-close-btn-in'; | |
| } | |
| } | |
| if(mfp.st.alignTop) { | |
| _wrapClasses += ' mfp-align-top'; | |
| } | |
| if(mfp.fixedContentPos) { | |
| mfp.wrap.css({ | |
| overflow: mfp.st.overflowY, | |
| overflowX: 'hidden', | |
| overflowY: mfp.st.overflowY | |
| }); | |
| } else { | |
| mfp.wrap.css({ | |
| top: _window.scrollTop(), | |
| position: 'absolute' | |
| }); | |
| } | |
| if( mfp.st.fixedBgPos === false || (mfp.st.fixedBgPos === 'auto' && !mfp.fixedContentPos) ) { | |
| mfp.bgOverlay.css({ | |
| height: _document.height(), | |
| position: 'absolute' | |
| }); | |
| } | |
| if(mfp.st.enableEscapeKey) { | |
| // Close on ESC key | |
| _document.on('keyup' + EVENT_NS, function(e) { | |
| if(e.keyCode === 27) { | |
| mfp.close(); | |
| } | |
| }); | |
| } | |
| _window.on('resize' + EVENT_NS, function() { | |
| mfp.updateSize(); | |
| }); | |
| if(!mfp.st.closeOnContentClick) { | |
| _wrapClasses += ' mfp-auto-cursor'; | |
| } | |
| if(_wrapClasses) | |
| mfp.wrap.addClass(_wrapClasses); | |
| // this triggers recalculation of layout, so we get it once to not to trigger twice | |
| var windowHeight = mfp.wH = _window.height(); | |
| var windowStyles = {}; | |
| if( mfp.fixedContentPos ) { | |
| if(mfp._hasScrollBar(windowHeight)){ | |
| var s = mfp._getScrollbarSize(); | |
| if(s) { | |
| windowStyles.marginRight = s; | |
| } | |
| } | |
| } | |
| if(mfp.fixedContentPos) { | |
| if(!mfp.isIE7) { | |
| windowStyles.overflow = 'hidden'; | |
| } else { | |
| // ie7 double-scroll bug | |
| $('body, html').css('overflow', 'hidden'); | |
| } | |
| } | |
| var classesToadd = mfp.st.mainClass; | |
| if(mfp.isIE7) { | |
| classesToadd += ' mfp-ie7'; | |
| } | |
| if(classesToadd) { | |
| mfp._addClassToMFP( classesToadd ); | |
| } | |
| // add content | |
| mfp.updateItemHTML(); | |
| _mfpTrigger('BuildControls'); | |
| // remove scrollbar, add margin e.t.c | |
| $('html').css(windowStyles); | |
| // add everything to DOM | |
| mfp.bgOverlay.add(mfp.wrap).prependTo( mfp.st.prependTo || _body ); | |
| // Save last focused element | |
| mfp._lastFocusedEl = document.activeElement; | |
| // Wait for next cycle to allow CSS transition | |
| setTimeout(function() { | |
| if(mfp.content) { | |
| mfp._addClassToMFP(READY_CLASS); | |
| mfp._setFocus(); | |
| } else { | |
| // if content is not defined (not loaded e.t.c) we add class only for BG | |
| mfp.bgOverlay.addClass(READY_CLASS); | |
| } | |
| // Trap the focus in popup | |
| _document.on('focusin' + EVENT_NS, mfp._onFocusIn); | |
| }, 16); | |
| mfp.isOpen = true; | |
| mfp.updateSize(windowHeight); | |
| _mfpTrigger(OPEN_EVENT); | |
| return data; | |
| }, | |
| /** | |
| * Closes the popup | |
| */ | |
| close: function() { | |
| if(!mfp.isOpen) return; | |
| _mfpTrigger(BEFORE_CLOSE_EVENT); | |
| mfp.isOpen = false; | |
| // for CSS3 animation | |
| if(mfp.st.removalDelay && !mfp.isLowIE && mfp.supportsTransition ) { | |
| mfp._addClassToMFP(REMOVING_CLASS); | |
| setTimeout(function() { | |
| mfp._close(); | |
| }, mfp.st.removalDelay); | |
| } else { | |
| mfp._close(); | |
| } | |
| }, | |
| /** | |
| * Helper for close() function | |
| */ | |
| _close: function() { | |
| _mfpTrigger(CLOSE_EVENT); | |
| var classesToRemove = REMOVING_CLASS + ' ' + READY_CLASS + ' '; | |
| mfp.bgOverlay.detach(); | |
| mfp.wrap.detach(); | |
| mfp.container.empty(); | |
| if(mfp.st.mainClass) { | |
| classesToRemove += mfp.st.mainClass + ' '; | |
| } | |
| mfp._removeClassFromMFP(classesToRemove); | |
| if(mfp.fixedContentPos) { | |
| var windowStyles = {marginRight: ''}; | |
| if(mfp.isIE7) { | |
| $('body, html').css('overflow', ''); | |
| } else { | |
| windowStyles.overflow = ''; | |
| } | |
| $('html').css(windowStyles); | |
| } | |
| _document.off('keyup' + EVENT_NS + ' focusin' + EVENT_NS); | |
| mfp.ev.off(EVENT_NS); | |
| // clean up DOM elements that aren't removed | |
| mfp.wrap.attr('class', 'mfp-wrap').removeAttr('style'); | |
| mfp.bgOverlay.attr('class', 'mfp-bg'); | |
| mfp.container.attr('class', 'mfp-container'); | |
| // remove close button from target element | |
| if(mfp.st.showCloseBtn && | |
| (!mfp.st.closeBtnInside || mfp.currTemplate[mfp.currItem.type] === true)) { | |
| if(mfp.currTemplate.closeBtn) | |
| mfp.currTemplate.closeBtn.detach(); | |
| } | |
| if(mfp._lastFocusedEl) { | |
| $(mfp._lastFocusedEl).focus(); // put tab focus back | |
| } | |
| mfp.currItem = null; | |
| mfp.content = null; | |
| mfp.currTemplate = null; | |
| mfp.prevHeight = 0; | |
| _mfpTrigger(AFTER_CLOSE_EVENT); | |
| }, | |
| updateSize: function(winHeight) { | |
| if(mfp.isIOS) { | |
| // fixes iOS nav bars https://github.com/dimsemenov/Magnific-Popup/issues/2 | |
| var zoomLevel = document.documentElement.clientWidth / window.innerWidth; | |
| var height = window.innerHeight * zoomLevel; | |
| mfp.wrap.css('height', height); | |
| mfp.wH = height; | |
| } else { | |
| mfp.wH = winHeight || _window.height(); | |
| } | |
| // Fixes #84: popup incorrectly positioned with position:relative on body | |
| if(!mfp.fixedContentPos) { | |
| mfp.wrap.css('height', mfp.wH); | |
| } | |
| _mfpTrigger('Resize'); | |
| }, | |
| /** | |
| * Set content of popup based on current index | |
| */ | |
| updateItemHTML: function() { | |
| var item = mfp.items[mfp.index]; | |
| // Detach and perform modifications | |
| mfp.contentContainer.detach(); | |
| if(mfp.content) | |
| mfp.content.detach(); | |
| if(!item.parsed) { | |
| item = mfp.parseEl( mfp.index ); | |
| } | |
| var type = item.type; | |
| _mfpTrigger('BeforeChange', [mfp.currItem ? mfp.currItem.type : '', type]); | |
| // BeforeChange event works like so: | |
| // _mfpOn('BeforeChange', function(e, prevType, newType) { }); | |
| mfp.currItem = item; | |
| if(!mfp.currTemplate[type]) { | |
| var markup = mfp.st[type] ? mfp.st[type].markup : false; | |
| // allows to modify markup | |
| _mfpTrigger('FirstMarkupParse', markup); | |
| if(markup) { | |
| mfp.currTemplate[type] = $(markup); | |
| } else { | |
| // if there is no markup found we just define that template is parsed | |
| mfp.currTemplate[type] = true; | |
| } | |
| } | |
| if(_prevContentType && _prevContentType !== item.type) { | |
| mfp.container.removeClass('mfp-'+_prevContentType+'-holder'); | |
| } | |
| var newContent = mfp['get' + type.charAt(0).toUpperCase() + type.slice(1)](item, mfp.currTemplate[type]); | |
| mfp.appendContent(newContent, type); | |
| item.preloaded = true; | |
| _mfpTrigger(CHANGE_EVENT, item); | |
| _prevContentType = item.type; | |
| // Append container back after its content changed | |
| mfp.container.prepend(mfp.contentContainer); | |
| _mfpTrigger('AfterChange'); | |
| }, | |
| /** | |
| * Set HTML content of popup | |
| */ | |
| appendContent: function(newContent, type) { | |
| mfp.content = newContent; | |
| if(newContent) { | |
| if(mfp.st.showCloseBtn && mfp.st.closeBtnInside && | |
| mfp.currTemplate[type] === true) { | |
| // if there is no markup, we just append close button element inside | |
| if(!mfp.content.find('.mfp-close').length) { | |
| mfp.content.append(_getCloseBtn()); | |
| } | |
| } else { | |
| mfp.content = newContent; | |
| } | |
| } else { | |
| mfp.content = ''; | |
| } | |
| _mfpTrigger(BEFORE_APPEND_EVENT); | |
| mfp.container.addClass('mfp-'+type+'-holder'); | |
| mfp.contentContainer.append(mfp.content); | |
| }, | |
| /** | |
| * Creates Magnific Popup data object based on given data | |
| * @param {int} index Index of item to parse | |
| */ | |
| parseEl: function(index) { | |
| var item = mfp.items[index], | |
| type; | |
| if(item.tagName) { | |
| item = { el: $(item) }; | |
| } else { | |
| type = item.type; | |
| item = { data: item, src: item.src }; | |
| } | |
| if(item.el) { | |
| var types = mfp.types; | |
| // check for 'mfp-TYPE' class | |
| for(var i = 0; i < types.length; i++) { | |
| if( item.el.hasClass('mfp-'+types[i]) ) { | |
| type = types[i]; | |
| break; | |
| } | |
| } | |
| item.src = item.el.attr('data-mfp-src'); | |
| if(!item.src) { | |
| item.src = item.el.attr('href'); | |
| } | |
| } | |
| item.type = type || mfp.st.type || 'inline'; | |
| item.index = index; | |
| item.parsed = true; | |
| mfp.items[index] = item; | |
| _mfpTrigger('ElementParse', item); | |
| return mfp.items[index]; | |
| }, | |
| /** | |
| * Initializes single popup or a group of popups | |
| */ | |
| addGroup: function(el, options) { | |
| var eHandler = function(e) { | |
| e.mfpEl = this; | |
| mfp._openClick(e, el, options); | |
| }; | |
| if(!options) { | |
| options = {}; | |
| } | |
| var eName = 'click.magnificPopup'; | |
| options.mainEl = el; | |
| if(options.items) { | |
| options.isObj = true; | |
| el.off(eName).on(eName, eHandler); | |
| } else { | |
| options.isObj = false; | |
| if(options.delegate) { | |
| el.off(eName).on(eName, options.delegate , eHandler); | |
| } else { | |
| options.items = el; | |
| el.off(eName).on(eName, eHandler); | |
| } | |
| } | |
| }, | |
| _openClick: function(e, el, options) { | |
| var midClick = options.midClick !== undefined ? options.midClick : $.magnificPopup.defaults.midClick; | |
| if(!midClick && ( e.which === 2 || e.ctrlKey || e.metaKey ) ) { | |
| return; | |
| } | |
| var disableOn = options.disableOn !== undefined ? options.disableOn : $.magnificPopup.defaults.disableOn; | |
| if(disableOn) { | |
| if($.isFunction(disableOn)) { | |
| if( !disableOn.call(mfp) ) { | |
| return true; | |
| } | |
| } else { // else it's number | |
| if( _window.width() < disableOn ) { | |
| return true; | |
| } | |
| } | |
| } | |
| if(e.type) { | |
| e.preventDefault(); | |
| // This will prevent popup from closing if element is inside and popup is already opened | |
| if(mfp.isOpen) { | |
| e.stopPropagation(); | |
| } | |
| } | |
| options.el = $(e.mfpEl); | |
| if(options.delegate) { | |
| options.items = el.find(options.delegate); | |
| } | |
| mfp.open(options); | |
| }, | |
| /** | |
| * Updates text on preloader | |
| */ | |
| updateStatus: function(status, text) { | |
| if(mfp.preloader) { | |
| if(_prevStatus !== status) { | |
| mfp.container.removeClass('mfp-s-'+_prevStatus); | |
| } | |
| if(!text && status === 'loading') { | |
| text = mfp.st.tLoading; | |
| } | |
| var data = { | |
| status: status, | |
| text: text | |
| }; | |
| // allows to modify status | |
| _mfpTrigger('UpdateStatus', data); | |
| status = data.status; | |
| text = data.text; | |
| mfp.preloader.html(text); | |
| mfp.preloader.find('a').on('click', function(e) { | |
| e.stopImmediatePropagation(); | |
| }); | |
| mfp.container.addClass('mfp-s-'+status); | |
| _prevStatus = status; | |
| } | |
| }, | |
| /* | |
| "Private" helpers that aren't private at all | |
| */ | |
| // Check to close popup or not | |
| // "target" is an element that was clicked | |
| _checkIfClose: function(target) { | |
| if($(target).hasClass(PREVENT_CLOSE_CLASS)) { | |
| return; | |
| } | |
| var closeOnContent = mfp.st.closeOnContentClick; | |
| var closeOnBg = mfp.st.closeOnBgClick; | |
| if(closeOnContent && closeOnBg) { | |
| return true; | |
| } else { | |
| // We close the popup if click is on close button or on preloader. Or if there is no content. | |
| if(!mfp.content || $(target).hasClass('mfp-close') || (mfp.preloader && target === mfp.preloader[0]) ) { | |
| return true; | |
| } | |
| // if click is outside the content | |
| if( (target !== mfp.content[0] && !$.contains(mfp.content[0], target)) ) { | |
| if(closeOnBg) { | |
| // last check, if the clicked element is in DOM, (in case it's removed onclick) | |
| if( $.contains(document, target) ) { | |
| return true; | |
| } | |
| } | |
| } else if(closeOnContent) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }, | |
| _addClassToMFP: function(cName) { | |
| mfp.bgOverlay.addClass(cName); | |
| mfp.wrap.addClass(cName); | |
| }, | |
| _removeClassFromMFP: function(cName) { | |
| this.bgOverlay.removeClass(cName); | |
| mfp.wrap.removeClass(cName); | |
| }, | |
| _hasScrollBar: function(winHeight) { | |
| return ( (mfp.isIE7 ? _document.height() : document.body.scrollHeight) > (winHeight || _window.height()) ); | |
| }, | |
| _setFocus: function() { | |
| (mfp.st.focus ? mfp.content.find(mfp.st.focus).eq(0) : mfp.wrap).focus(); | |
| }, | |
| _onFocusIn: function(e) { | |
| if( e.target !== mfp.wrap[0] && !$.contains(mfp.wrap[0], e.target) ) { | |
| mfp._setFocus(); | |
| return false; | |
| } | |
| }, | |
| _parseMarkup: function(template, values, item) { | |
| var arr; | |
| if(item.data) { | |
| values = $.extend(item.data, values); | |
| } | |
| _mfpTrigger(MARKUP_PARSE_EVENT, [template, values, item] ); | |
| $.each(values, function(key, value) { | |
| if(value === undefined || value === false) { | |
| return true; | |
| } | |
| arr = key.split('_'); | |
| if(arr.length > 1) { | |
| var el = template.find(EVENT_NS + '-'+arr[0]); | |
| if(el.length > 0) { | |
| var attr = arr[1]; | |
| if(attr === 'replaceWith') { | |
| if(el[0] !== value[0]) { | |
| el.replaceWith(value); | |
| } | |
| } else if(attr === 'img') { | |
| if(el.is('img')) { | |
| el.attr('src', value); | |
| } else { | |
| el.replaceWith( '<img src="'+value+'" class="' + el.attr('class') + '" />' ); | |
| } | |
| } else { | |
| el.attr(arr[1], value); | |
| } | |
| } | |
| } else { | |
| template.find(EVENT_NS + '-'+key).html(value); | |
| } | |
| }); | |
| }, | |
| _getScrollbarSize: function() { | |
| // thx David | |
| if(mfp.scrollbarSize === undefined) { | |
| var scrollDiv = document.createElement("div"); | |
| scrollDiv.style.cssText = 'width: 99px; height: 99px; overflow: scroll; position: absolute; top: -9999px;'; | |
| document.body.appendChild(scrollDiv); | |
| mfp.scrollbarSize = scrollDiv.offsetWidth - scrollDiv.clientWidth; | |
| document.body.removeChild(scrollDiv); | |
| } | |
| return mfp.scrollbarSize; | |
| } | |
| }; /* MagnificPopup core prototype end */ | |
| /** | |
| * Public static functions | |
| */ | |
| $.magnificPopup = { | |
| instance: null, | |
| proto: MagnificPopup.prototype, | |
| modules: [], | |
| open: function(options, index) { | |
| _checkInstance(); | |
| if(!options) { | |
| options = {}; | |
| } else { | |
| options = $.extend(true, {}, options); | |
| } | |
| options.isObj = true; | |
| options.index = index || 0; | |
| return this.instance.open(options); | |
| }, | |
| close: function() { | |
| return $.magnificPopup.instance && $.magnificPopup.instance.close(); | |
| }, | |
| registerModule: function(name, module) { | |
| if(module.options) { | |
| $.magnificPopup.defaults[name] = module.options; | |
| } | |
| $.extend(this.proto, module.proto); | |
| this.modules.push(name); | |
| }, | |
| defaults: { | |
| // Info about options is in docs: | |
| // http://dimsemenov.com/plugins/magnific-popup/documentation.html#options | |
| disableOn: 0, | |
| key: null, | |
| midClick: false, | |
| mainClass: '', | |
| preloader: true, | |
| focus: '', // CSS selector of input to focus after popup is opened | |
| closeOnContentClick: false, | |
| closeOnBgClick: true, | |
| closeBtnInside: true, | |
| showCloseBtn: true, | |
| enableEscapeKey: true, | |
| modal: false, | |
| alignTop: false, | |
| removalDelay: 0, | |
| prependTo: null, | |
| fixedContentPos: 'auto', | |
| fixedBgPos: 'auto', | |
| overflowY: 'auto', | |
| closeMarkup: '<button title="%title%" type="button" class="mfp-close">×</button>', | |
| tClose: 'Close (Esc)', | |
| tLoading: 'Loading...' | |
| } | |
| }; | |
| $.fn.magnificPopup = function(options) { | |
| _checkInstance(); | |
| var jqEl = $(this); | |
| // We call some API method of first param is a string | |
| if (typeof options === "string" ) { | |
| if(options === 'open') { | |
| var items, | |
| itemOpts = _isJQ ? jqEl.data('magnificPopup') : jqEl[0].magnificPopup, | |
| index = parseInt(arguments[1], 10) || 0; | |
| if(itemOpts.items) { | |
| items = itemOpts.items[index]; | |
| } else { | |
| items = jqEl; | |
| if(itemOpts.delegate) { | |
| items = items.find(itemOpts.delegate); | |
| } | |
| items = items.eq( index ); | |
| } | |
| mfp._openClick({mfpEl:items}, jqEl, itemOpts); | |
| } else { | |
| if(mfp.isOpen) | |
| mfp[options].apply(mfp, Array.prototype.slice.call(arguments, 1)); | |
| } | |
| } else { | |
| // clone options obj | |
| options = $.extend(true, {}, options); | |
| /* | |
| * As Zepto doesn't support .data() method for objects | |
| * and it works only in normal browsers | |
| * we assign "options" object directly to the DOM element. FTW! | |
| */ | |
| if(_isJQ) { | |
| jqEl.data('magnificPopup', options); | |
| } else { | |
| jqEl[0].magnificPopup = options; | |
| } | |
| mfp.addGroup(jqEl, options); | |
| } | |
| return jqEl; | |
| }; | |
| //Quick benchmark | |
| /* | |
| var start = performance.now(), | |
| i, | |
| rounds = 1000; | |
| for(i = 0; i < rounds; i++) { | |
| } | |
| console.log('Test #1:', performance.now() - start); | |
| start = performance.now(); | |
| for(i = 0; i < rounds; i++) { | |
| } | |
| console.log('Test #2:', performance.now() - start); | |
| */ | |
| /*>>core*/ | |
| /*>>inline*/ | |
| var INLINE_NS = 'inline', | |
| _hiddenClass, | |
| _inlinePlaceholder, | |
| _lastInlineElement, | |
| _putInlineElementsBack = function() { | |
| if(_lastInlineElement) { | |
| _inlinePlaceholder.after( _lastInlineElement.addClass(_hiddenClass) ).detach(); | |
| _lastInlineElement = null; | |
| } | |
| }; | |
| $.magnificPopup.registerModule(INLINE_NS, { | |
| options: { | |
| hiddenClass: 'hide', // will be appended with `mfp-` prefix | |
| markup: '', | |
| tNotFound: 'Content not found' | |
| }, | |
| proto: { | |
| initInline: function() { | |
| mfp.types.push(INLINE_NS); | |
| _mfpOn(CLOSE_EVENT+'.'+INLINE_NS, function() { | |
| _putInlineElementsBack(); | |
| }); | |
| }, | |
| getInline: function(item, template) { | |
| _putInlineElementsBack(); | |
| if(item.src) { | |
| var inlineSt = mfp.st.inline, | |
| el = $(item.src); | |
| if(el.length) { | |
| // If target element has parent - we replace it with placeholder and put it back after popup is closed | |
| var parent = el[0].parentNode; | |
| if(parent && parent.tagName) { | |
| if(!_inlinePlaceholder) { | |
| _hiddenClass = inlineSt.hiddenClass; | |
| _inlinePlaceholder = _getEl(_hiddenClass); | |
| _hiddenClass = 'mfp-'+_hiddenClass; | |
| } | |
| // replace target inline element with placeholder | |
| _lastInlineElement = el.after(_inlinePlaceholder).detach().removeClass(_hiddenClass); | |
| } | |
| mfp.updateStatus('ready'); | |
| } else { | |
| mfp.updateStatus('error', inlineSt.tNotFound); | |
| el = $('<div>'); | |
| } | |
| item.inlineElement = el; | |
| return el; | |
| } | |
| mfp.updateStatus('ready'); | |
| mfp._parseMarkup(template, {}, item); | |
| return template; | |
| } | |
| } | |
| }); | |
| /*>>inline*/ | |
| /*>>ajax*/ | |
| var AJAX_NS = 'ajax', | |
| _ajaxCur, | |
| _removeAjaxCursor = function() { | |
| if(_ajaxCur) { | |
| _body.removeClass(_ajaxCur); | |
| } | |
| }, | |
| _destroyAjaxRequest = function() { | |
| _removeAjaxCursor(); | |
| if(mfp.req) { | |
| mfp.req.abort(); | |
| } | |
| }; | |
| $.magnificPopup.registerModule(AJAX_NS, { | |
| options: { | |
| settings: null, | |
| cursor: 'mfp-ajax-cur', | |
| tError: '<a href="%url%">The content</a> could not be loaded.' | |
| }, | |
| proto: { | |
| initAjax: function() { | |
| mfp.types.push(AJAX_NS); | |
| _ajaxCur = mfp.st.ajax.cursor; | |
| _mfpOn(CLOSE_EVENT+'.'+AJAX_NS, _destroyAjaxRequest); | |
| _mfpOn('BeforeChange.' + AJAX_NS, _destroyAjaxRequest); | |
| }, | |
| getAjax: function(item) { | |
| if(_ajaxCur) | |
| _body.addClass(_ajaxCur); | |
| mfp.updateStatus('loading'); | |
| var opts = $.extend({ | |
| url: item.src, | |
| success: function(data, textStatus, jqXHR) { | |
| var temp = { | |
| data:data, | |
| xhr:jqXHR | |
| }; | |
| _mfpTrigger('ParseAjax', temp); | |
| mfp.appendContent( $(temp.data), AJAX_NS ); | |
| item.finished = true; | |
| _removeAjaxCursor(); | |
| mfp._setFocus(); | |
| setTimeout(function() { | |
| mfp.wrap.addClass(READY_CLASS); | |
| }, 16); | |
| mfp.updateStatus('ready'); | |
| _mfpTrigger('AjaxContentAdded'); | |
| }, | |
| error: function() { | |
| _removeAjaxCursor(); | |
| item.finished = item.loadError = true; | |
| mfp.updateStatus('error', mfp.st.ajax.tError.replace('%url%', item.src)); | |
| } | |
| }, mfp.st.ajax.settings); | |
| mfp.req = $.ajax(opts); | |
| return ''; | |
| } | |
| } | |
| }); | |
| /*>>ajax*/ | |
| /*>>image*/ | |
| var _imgInterval, | |
| _getTitle = function(item) { | |
| if(item.data && item.data.title !== undefined) | |
| return item.data.title; | |
| var src = mfp.st.image.titleSrc; | |
| if(src) { | |
| if($.isFunction(src)) { | |
| return src.call(mfp, item); | |
| } else if(item.el) { | |
| return item.el.attr(src) || ''; | |
| } | |
| } | |
| return ''; | |
| }; | |
| $.magnificPopup.registerModule('image', { | |
| options: { | |
| markup: '<div class="mfp-figure">'+ | |
| '<div class="mfp-close"></div>'+ | |
| '<figure>'+ | |
| '<div class="mfp-img"></div>'+ | |
| '<figcaption>'+ | |
| '<div class="mfp-bottom-bar">'+ | |
| '<div class="mfp-title"></div>'+ | |
| '<div class="mfp-counter"></div>'+ | |
| '</div>'+ | |
| '</figcaption>'+ | |
| '</figure>'+ | |
| '</div>', | |
| cursor: 'mfp-zoom-out-cur', | |
| titleSrc: 'title', | |
| verticalFit: true, | |
| tError: '<a href="%url%">The image</a> could not be loaded.' | |
| }, | |
| proto: { | |
| initImage: function() { | |
| var imgSt = mfp.st.image, | |
| ns = '.image'; | |
| mfp.types.push('image'); | |
| _mfpOn(OPEN_EVENT+ns, function() { | |
| if(mfp.currItem.type === 'image' && imgSt.cursor) { | |
| _body.addClass(imgSt.cursor); | |
| } | |
| }); | |
| _mfpOn(CLOSE_EVENT+ns, function() { | |
| if(imgSt.cursor) { | |
| _body.removeClass(imgSt.cursor); | |
| } | |
| _window.off('resize' + EVENT_NS); | |
| }); | |
| _mfpOn('Resize'+ns, mfp.resizeImage); | |
| if(mfp.isLowIE) { | |
| _mfpOn('AfterChange', mfp.resizeImage); | |
| } | |
| }, | |
| resizeImage: function() { | |
| var item = mfp.currItem; | |
| if(!item || !item.img) return; | |
| if(mfp.st.image.verticalFit) { | |
| var decr = 0; | |
| // fix box-sizing in ie7/8 | |
| if(mfp.isLowIE) { | |
| decr = parseInt(item.img.css('padding-top'), 10) + parseInt(item.img.css('padding-bottom'),10); | |
| } | |
| item.img.css('max-height', mfp.wH-decr); | |
| } | |
| }, | |
| _onImageHasSize: function(item) { | |
| if(item.img) { | |
| item.hasSize = true; | |
| if(_imgInterval) { | |
| clearInterval(_imgInterval); | |
| } | |
| item.isCheckingImgSize = false; | |
| _mfpTrigger('ImageHasSize', item); | |
| if(item.imgHidden) { | |
| if(mfp.content) | |
| mfp.content.removeClass('mfp-loading'); | |
| item.imgHidden = false; | |
| } | |
| } | |
| }, | |
| /** | |
| * Function that loops until the image has size to display elements that rely on it asap | |
| */ | |
| findImageSize: function(item) { | |
| var counter = 0, | |
| img = item.img[0], | |
| mfpSetInterval = function(delay) { | |
| if(_imgInterval) { | |
| clearInterval(_imgInterval); | |
| } | |
| // decelerating interval that checks for size of an image | |
| _imgInterval = setInterval(function() { | |
| if(img.naturalWidth > 0) { | |
| mfp._onImageHasSize(item); | |
| return; | |
| } | |
| if(counter > 200) { | |
| clearInterval(_imgInterval); | |
| } | |
| counter++; | |
| if(counter === 3) { | |
| mfpSetInterval(10); | |
| } else if(counter === 40) { | |
| mfpSetInterval(50); | |
| } else if(counter === 100) { | |
| mfpSetInterval(500); | |
| } | |
| }, delay); | |
| }; | |
| mfpSetInterval(1); | |
| }, | |
| getImage: function(item, template) { | |
| var guard = 0, | |
| // image load complete handler | |
| onLoadComplete = function() { | |
| if(item) { | |
| if (item.img[0].complete) { | |
| item.img.off('.mfploader'); | |
| if(item === mfp.currItem){ | |
| mfp._onImageHasSize(item); | |
| mfp.updateStatus('ready'); | |
| } | |
| item.hasSize = true; | |
| item.loaded = true; | |
| _mfpTrigger('ImageLoadComplete'); | |
| } | |
| else { | |
| // if image complete check fails 200 times (20 sec), we assume that there was an error. | |
| guard++; | |
| if(guard < 200) { | |
| setTimeout(onLoadComplete,100); | |
| } else { | |
| onLoadError(); | |
| } | |
| } | |
| } | |
| }, | |
| // image error handler | |
| onLoadError = function() { | |
| if(item) { | |
| item.img.off('.mfploader'); | |
| if(item === mfp.currItem){ | |
| mfp._onImageHasSize(item); | |
| mfp.updateStatus('error', imgSt.tError.replace('%url%', item.src) ); | |
| } | |
| item.hasSize = true; | |
| item.loaded = true; | |
| item.loadError = true; | |
| } | |
| }, | |
| imgSt = mfp.st.image; | |
| var el = template.find('.mfp-img'); | |
| if(el.length) { | |
| var img = document.createElement('img'); | |
| img.className = 'mfp-img'; | |
| item.img = $(img).on('load.mfploader', onLoadComplete).on('error.mfploader', onLoadError); | |
| img.src = item.src; | |
| // without clone() "error" event is not firing when IMG is replaced by new IMG | |
| // TODO: find a way to avoid such cloning | |
| if(el.is('img')) { | |
| item.img = item.img.clone(); | |
| } | |
| img = item.img[0]; | |
| if(img.naturalWidth > 0) { | |
| item.hasSize = true; | |
| } else if(!img.width) { | |
| item.hasSize = false; | |
| } | |
| } | |
| mfp._parseMarkup(template, { | |
| title: _getTitle(item), | |
| img_replaceWith: item.img | |
| }, item); | |
| mfp.resizeImage(); | |
| if(item.hasSize) { | |
| if(_imgInterval) clearInterval(_imgInterval); | |
| if(item.loadError) { | |
| template.addClass('mfp-loading'); | |
| mfp.updateStatus('error', imgSt.tError.replace('%url%', item.src) ); | |
| } else { | |
| template.removeClass('mfp-loading'); | |
| mfp.updateStatus('ready'); | |
| } | |
| return template; | |
| } | |
| mfp.updateStatus('loading'); | |
| item.loading = true; | |
| if(!item.hasSize) { | |
| item.imgHidden = true; | |
| template.addClass('mfp-loading'); | |
| mfp.findImageSize(item); | |
| } | |
| return template; | |
| } | |
| } | |
| }); | |
| /*>>image*/ | |
| /*>>zoom*/ | |
| var hasMozTransform, | |
| getHasMozTransform = function() { | |
| if(hasMozTransform === undefined) { | |
| hasMozTransform = document.createElement('p').style.MozTransform !== undefined; | |
| } | |
| return hasMozTransform; | |
| }; | |
| $.magnificPopup.registerModule('zoom', { | |
| options: { | |
| enabled: false, | |
| easing: 'ease-in-out', | |
| duration: 300, | |
| opener: function(element) { | |
| return element.is('img') ? element : element.find('img'); | |
| } | |
| }, | |
| proto: { | |
| initZoom: function() { | |
| var zoomSt = mfp.st.zoom, | |
| ns = '.zoom', | |
| image; | |
| if(!zoomSt.enabled || !mfp.supportsTransition) { | |
| return; | |
| } | |
| var duration = zoomSt.duration, | |
| getElToAnimate = function(image) { | |
| var newImg = image.clone().removeAttr('style').removeAttr('class').addClass('mfp-animated-image'), | |
| transition = 'all '+(zoomSt.duration/1000)+'s ' + zoomSt.easing, | |
| cssObj = { | |
| position: 'fixed', | |
| zIndex: 9999, | |
| left: 0, | |
| top: 0, | |
| '-webkit-backface-visibility': 'hidden' | |
| }, | |
| t = 'transition'; | |
| cssObj['-webkit-'+t] = cssObj['-moz-'+t] = cssObj['-o-'+t] = cssObj[t] = transition; | |
| newImg.css(cssObj); | |
| return newImg; | |
| }, | |
| showMainContent = function() { | |
| mfp.content.css('visibility', 'visible'); | |
| }, | |
| openTimeout, | |
| animatedImg; | |
| _mfpOn('BuildControls'+ns, function() { | |
| if(mfp._allowZoom()) { | |
| clearTimeout(openTimeout); | |
| mfp.content.css('visibility', 'hidden'); | |
| // Basically, all code below does is clones existing image, puts in on top of the current one and animated it | |
| image = mfp._getItemToZoom(); | |
| if(!image) { | |
| showMainContent(); | |
| return; | |
| } | |
| animatedImg = getElToAnimate(image); | |
| animatedImg.css( mfp._getOffset() ); | |
| mfp.wrap.append(animatedImg); | |
| openTimeout = setTimeout(function() { | |
| animatedImg.css( mfp._getOffset( true ) ); | |
| openTimeout = setTimeout(function() { | |
| showMainContent(); | |
| setTimeout(function() { | |
| animatedImg.remove(); | |
| image = animatedImg = null; | |
| _mfpTrigger('ZoomAnimationEnded'); | |
| }, 16); // avoid blink when switching images | |
| }, duration); // this timeout equals animation duration | |
| }, 16); // by adding this timeout we avoid short glitch at the beginning of animation | |
| // Lots of timeouts... | |
| } | |
| }); | |
| _mfpOn(BEFORE_CLOSE_EVENT+ns, function() { | |
| if(mfp._allowZoom()) { | |
| clearTimeout(openTimeout); | |
| mfp.st.removalDelay = duration; | |
| if(!image) { | |
| image = mfp._getItemToZoom(); | |
| if(!image) { | |
| return; | |
| } | |
| animatedImg = getElToAnimate(image); | |
| } | |
| animatedImg.css( mfp._getOffset(true) ); | |
| mfp.wrap.append(animatedImg); | |
| mfp.content.css('visibility', 'hidden'); | |
| setTimeout(function() { | |
| animatedImg.css( mfp._getOffset() ); | |
| }, 16); | |
| } | |
| }); | |
| _mfpOn(CLOSE_EVENT+ns, function() { | |
| if(mfp._allowZoom()) { | |
| showMainContent(); | |
| if(animatedImg) { | |
| animatedImg.remove(); | |
| } | |
| image = null; | |
| } | |
| }); | |
| }, | |
| _allowZoom: function() { | |
| return mfp.currItem.type === 'image'; | |
| }, | |
| _getItemToZoom: function() { | |
| if(mfp.currItem.hasSize) { | |
| return mfp.currItem.img; | |
| } else { | |
| return false; | |
| } | |
| }, | |
| // Get element postion relative to viewport | |
| _getOffset: function(isLarge) { | |
| var el; | |
| if(isLarge) { | |
| el = mfp.currItem.img; | |
| } else { | |
| el = mfp.st.zoom.opener(mfp.currItem.el || mfp.currItem); | |
| } | |
| var offset = el.offset(); | |
| var paddingTop = parseInt(el.css('padding-top'),10); | |
| var paddingBottom = parseInt(el.css('padding-bottom'),10); | |
| offset.top -= ( $(window).scrollTop() - paddingTop ); | |
| /* | |
| Animating left + top + width/height looks glitchy in Firefox, but perfect in Chrome. And vice-versa. | |
| */ | |
| var obj = { | |
| width: el.width(), | |
| // fix Zepto height+padding issue | |
| height: (_isJQ ? el.innerHeight() : el[0].offsetHeight) - paddingBottom - paddingTop | |
| }; | |
| // I hate to do this, but there is no another option | |
| if( getHasMozTransform() ) { | |
| obj['-moz-transform'] = obj['transform'] = 'translate(' + offset.left + 'px,' + offset.top + 'px)'; | |
| } else { | |
| obj.left = offset.left; | |
| obj.top = offset.top; | |
| } | |
| return obj; | |
| } | |
| } | |
| }); | |
| /*>>zoom*/ | |
| /*>>iframe*/ | |
| var IFRAME_NS = 'iframe', | |
| _emptyPage = '//about:blank', | |
| _fixIframeBugs = function(isShowing) { | |
| if(mfp.currTemplate[IFRAME_NS]) { | |
| var el = mfp.currTemplate[IFRAME_NS].find('iframe'); | |
| if(el.length) { | |
| // reset src after the popup is closed to avoid "video keeps playing after popup is closed" bug | |
| if(!isShowing) { | |
| el[0].src = _emptyPage; | |
| } | |
| // IE8 black screen bug fix | |
| if(mfp.isIE8) { | |
| el.css('display', isShowing ? 'block' : 'none'); | |
| } | |
| } | |
| } | |
| }; | |
| $.magnificPopup.registerModule(IFRAME_NS, { | |
| options: { | |
| markup: '<div class="mfp-iframe-scaler">'+ | |
| '<div class="mfp-close"></div>'+ | |
| '<iframe class="mfp-iframe" src="//about:blank" frameborder="0" allowfullscreen></iframe>'+ | |
| '</div>', | |
| srcAction: 'iframe_src', | |
| // we don't care and support only one default type of URL by default | |
| patterns: { | |
| youtube: { | |
| index: 'youtube.com', | |
| id: 'v=', | |
| src: '//www.youtube.com/embed/%id%?autoplay=1' | |
| }, | |
| vimeo: { | |
| index: 'vimeo.com/', | |
| id: '/', | |
| src: '//player.vimeo.com/video/%id%?autoplay=1' | |
| }, | |
| gmaps: { | |
| index: '//maps.google.', | |
| src: '%id%&output=embed' | |
| } | |
| } | |
| }, | |
| proto: { | |
| initIframe: function() { | |
| mfp.types.push(IFRAME_NS); | |
| _mfpOn('BeforeChange', function(e, prevType, newType) { | |
| if(prevType !== newType) { | |
| if(prevType === IFRAME_NS) { | |
| _fixIframeBugs(); // iframe if removed | |
| } else if(newType === IFRAME_NS) { | |
| _fixIframeBugs(true); // iframe is showing | |
| } | |
| }// else { | |
| // iframe source is switched, don't do anything | |
| //} | |
| }); | |
| _mfpOn(CLOSE_EVENT + '.' + IFRAME_NS, function() { | |
| _fixIframeBugs(); | |
| }); | |
| }, | |
| getIframe: function(item, template) { | |
| var embedSrc = item.src; | |
| var iframeSt = mfp.st.iframe; | |
| $.each(iframeSt.patterns, function() { | |
| if(embedSrc.indexOf( this.index ) > -1) { | |
| if(this.id) { | |
| if(typeof this.id === 'string') { | |
| embedSrc = embedSrc.substr(embedSrc.lastIndexOf(this.id)+this.id.length, embedSrc.length); | |
| } else { | |
| embedSrc = this.id.call( this, embedSrc ); | |
| } | |
| } | |
| embedSrc = this.src.replace('%id%', embedSrc ); | |
| return false; // break; | |
| } | |
| }); | |
| var dataObj = {}; | |
| if(iframeSt.srcAction) { | |
| dataObj[iframeSt.srcAction] = embedSrc; | |
| } | |
| mfp._parseMarkup(template, dataObj, item); | |
| mfp.updateStatus('ready'); | |
| return template; | |
| } | |
| } | |
| }); | |
| /*>>iframe*/ | |
| /*>>gallery*/ | |
| /** | |
| * Get looped index depending on number of slides | |
| */ | |
| var _getLoopedId = function(index) { | |
| var numSlides = mfp.items.length; | |
| if(index > numSlides - 1) { | |
| return index - numSlides; | |
| } else if(index < 0) { | |
| return numSlides + index; | |
| } | |
| return index; | |
| }, | |
| _replaceCurrTotal = function(text, curr, total) { | |
| return text.replace(/%curr%/gi, curr + 1).replace(/%total%/gi, total); | |
| }; | |
| $.magnificPopup.registerModule('gallery', { | |
| options: { | |
| enabled: false, | |
| arrowMarkup: '<button title="%title%" type="button" class="mfp-arrow mfp-arrow-%dir%"></button>', | |
| preload: [0,2], | |
| navigateByImgClick: true, | |
| arrows: true, | |
| tPrev: 'Previous (Left arrow key)', | |
| tNext: 'Next (Right arrow key)', | |
| tCounter: '%curr% of %total%' | |
| }, | |
| proto: { | |
| initGallery: function() { | |
| var gSt = mfp.st.gallery, | |
| ns = '.mfp-gallery', | |
| supportsFastClick = Boolean($.fn.mfpFastClick); | |
| mfp.direction = true; // true - next, false - prev | |
| if(!gSt || !gSt.enabled ) return false; | |
| _wrapClasses += ' mfp-gallery'; | |
| _mfpOn(OPEN_EVENT+ns, function() { | |
| if(gSt.navigateByImgClick) { | |
| mfp.wrap.on('click'+ns, '.mfp-img', function() { | |
| if(mfp.items.length > 1) { | |
| mfp.next(); | |
| return false; | |
| } | |
| }); | |
| } | |
| _document.on('keydown'+ns, function(e) { | |
| if (e.keyCode === 37) { | |
| mfp.prev(); | |
| } else if (e.keyCode === 39) { | |
| mfp.next(); | |
| } | |
| }); | |
| }); | |
| _mfpOn('UpdateStatus'+ns, function(e, data) { | |
| if(data.text) { | |
| data.text = _replaceCurrTotal(data.text, mfp.currItem.index, mfp.items.length); | |
| } | |
| }); | |
| _mfpOn(MARKUP_PARSE_EVENT+ns, function(e, element, values, item) { | |
| var l = mfp.items.length; | |
| values.counter = l > 1 ? _replaceCurrTotal(gSt.tCounter, item.index, l) : ''; | |
| }); | |
| _mfpOn('BuildControls' + ns, function() { | |
| if(mfp.items.length > 1 && gSt.arrows && !mfp.arrowLeft) { | |
| var markup = gSt.arrowMarkup, | |
| arrowLeft = mfp.arrowLeft = $( markup.replace(/%title%/gi, gSt.tPrev).replace(/%dir%/gi, 'left') ).addClass(PREVENT_CLOSE_CLASS), | |
| arrowRight = mfp.arrowRight = $( markup.replace(/%title%/gi, gSt.tNext).replace(/%dir%/gi, 'right') ).addClass(PREVENT_CLOSE_CLASS); | |
| var eName = supportsFastClick ? 'mfpFastClick' : 'click'; | |
| arrowLeft[eName](function() { | |
| mfp.prev(); | |
| }); | |
| arrowRight[eName](function() { | |
| mfp.next(); | |
| }); | |
| // Polyfill for :before and :after (adds elements with classes mfp-a and mfp-b) | |
| if(mfp.isIE7) { | |
| _getEl('b', arrowLeft[0], false, true); | |
| _getEl('a', arrowLeft[0], false, true); | |
| _getEl('b', arrowRight[0], false, true); | |
| _getEl('a', arrowRight[0], false, true); | |
| } | |
| mfp.container.append(arrowLeft.add(arrowRight)); | |
| } | |
| }); | |
| _mfpOn(CHANGE_EVENT+ns, function() { | |
| if(mfp._preloadTimeout) clearTimeout(mfp._preloadTimeout); | |
| mfp._preloadTimeout = setTimeout(function() { | |
| mfp.preloadNearbyImages(); | |
| mfp._preloadTimeout = null; | |
| }, 16); | |
| }); | |
| _mfpOn(CLOSE_EVENT+ns, function() { | |
| _document.off(ns); | |
| mfp.wrap.off('click'+ns); | |
| if(mfp.arrowLeft && supportsFastClick) { | |
| mfp.arrowLeft.add(mfp.arrowRight).destroyMfpFastClick(); | |
| } | |
| mfp.arrowRight = mfp.arrowLeft = null; | |
| }); | |
| }, | |
| next: function() { | |
| mfp.direction = true; | |
| mfp.index = _getLoopedId(mfp.index + 1); | |
| mfp.updateItemHTML(); | |
| }, | |
| prev: function() { | |
| mfp.direction = false; | |
| mfp.index = _getLoopedId(mfp.index - 1); | |
| mfp.updateItemHTML(); | |
| }, | |
| goTo: function(newIndex) { | |
| mfp.direction = (newIndex >= mfp.index); | |
| mfp.index = newIndex; | |
| mfp.updateItemHTML(); | |
| }, | |
| preloadNearbyImages: function() { | |
| var p = mfp.st.gallery.preload, | |
| preloadBefore = Math.min(p[0], mfp.items.length), | |
| preloadAfter = Math.min(p[1], mfp.items.length), | |
| i; | |
| for(i = 1; i <= (mfp.direction ? preloadAfter : preloadBefore); i++) { | |
| mfp._preloadItem(mfp.index+i); | |
| } | |
| for(i = 1; i <= (mfp.direction ? preloadBefore : preloadAfter); i++) { | |
| mfp._preloadItem(mfp.index-i); | |
| } | |
| }, | |
| _preloadItem: function(index) { | |
| index = _getLoopedId(index); | |
| if(mfp.items[index].preloaded) { | |
| return; | |
| } | |
| var item = mfp.items[index]; | |
| if(!item.parsed) { | |
| item = mfp.parseEl( index ); | |
| } | |
| _mfpTrigger('LazyLoad', item); | |
| if(item.type === 'image') { | |
| item.img = $('<img class="mfp-img" />').on('load.mfploader', function() { | |
| item.hasSize = true; | |
| }).on('error.mfploader', function() { | |
| item.hasSize = true; | |
| item.loadError = true; | |
| _mfpTrigger('LazyLoadError', item); | |
| }).attr('src', item.src); | |
| } | |
| item.preloaded = true; | |
| } | |
| } | |
| }); | |
| /* | |
| Touch Support that might be implemented some day | |
| addSwipeGesture: function() { | |
| var startX, | |
| moved, | |
| multipleTouches; | |
| return; | |
| var namespace = '.mfp', | |
| addEventNames = function(pref, down, move, up, cancel) { | |
| mfp._tStart = pref + down + namespace; | |
| mfp._tMove = pref + move + namespace; | |
| mfp._tEnd = pref + up + namespace; | |
| mfp._tCancel = pref + cancel + namespace; | |
| }; | |
| if(window.navigator.msPointerEnabled) { | |
| addEventNames('MSPointer', 'Down', 'Move', 'Up', 'Cancel'); | |
| } else if('ontouchstart' in window) { | |
| addEventNames('touch', 'start', 'move', 'end', 'cancel'); | |
| } else { | |
| return; | |
| } | |
| _window.on(mfp._tStart, function(e) { | |
| var oE = e.originalEvent; | |
| multipleTouches = moved = false; | |
| startX = oE.pageX || oE.changedTouches[0].pageX; | |
| }).on(mfp._tMove, function(e) { | |
| if(e.originalEvent.touches.length > 1) { | |
| multipleTouches = e.originalEvent.touches.length; | |
| } else { | |
| //e.preventDefault(); | |
| moved = true; | |
| } | |
| }).on(mfp._tEnd + ' ' + mfp._tCancel, function(e) { | |
| if(moved && !multipleTouches) { | |
| var oE = e.originalEvent, | |
| diff = startX - (oE.pageX || oE.changedTouches[0].pageX); | |
| if(diff > 20) { | |
| mfp.next(); | |
| } else if(diff < -20) { | |
| mfp.prev(); | |
| } | |
| } | |
| }); | |
| }, | |
| */ | |
| /*>>gallery*/ | |
| /*>>retina*/ | |
| var RETINA_NS = 'retina'; | |
| $.magnificPopup.registerModule(RETINA_NS, { | |
| options: { | |
| replaceSrc: function(item) { | |
| return item.src.replace(/\.\w+$/, function(m) { return '@2x' + m; }); | |
| }, | |
| ratio: 1 // Function or number. Set to 1 to disable. | |
| }, | |
| proto: { | |
| initRetina: function() { | |
| if(window.devicePixelRatio > 1) { | |
| var st = mfp.st.retina, | |
| ratio = st.ratio; | |
| ratio = !isNaN(ratio) ? ratio : ratio(); | |
| if(ratio > 1) { | |
| _mfpOn('ImageHasSize' + '.' + RETINA_NS, function(e, item) { | |
| item.img.css({ | |
| 'max-width': item.img[0].naturalWidth / ratio, | |
| 'width': '100%' | |
| }); | |
| }); | |
| _mfpOn('ElementParse' + '.' + RETINA_NS, function(e, item) { | |
| item.src = st.replaceSrc(item, ratio); | |
| }); | |
| } | |
| } | |
| } | |
| } | |
| }); | |
| /*>>retina*/ | |
| _checkInstance(); })); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment