Permalink
Jump to Line
Branch:
master
Users who have contributed to this file
/*! Magnific Popup - v1.0.0 - 2015-09-17 | |
* http://dimsemenov.com/plugins/magnific-popup/ | |
* Copyright (c) 2015 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 | |
*/ | |
/*jshint -W079 */ | |
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), | |
_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) { | |
/*jshint -W020 */ | |
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) { | |
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 || $(document.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 || e.altKey || e.shiftKey ) ) { | |
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) { | |
$(document.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) { | |
$(document.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) { | |
$(document.body).addClass(imgSt.cursor); | |
} | |
}); | |
_mfpOn(CLOSE_EVENT+ns, function() { | |
if(imgSt.cursor) { | |
$(document.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'; | |
if(item.el && item.el.find('img').length) { | |
img.alt = item.el.find('img').attr('alt'); | |
} | |
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*/ | |
/*>>fastclick*/ | |
/** | |
* FastClick event implementation. (removes 300ms delay on touch devices) | |
* Based on https://developers.google.com/mobile/articles/fast_buttons | |
* | |
* You may use it outside the Magnific Popup by calling just: | |
* | |
* $('.your-el').mfpFastClick(function() { | |
* console.log('Clicked!'); | |
* }); | |
* | |
* To unbind: | |
* $('.your-el').destroyMfpFastClick(); | |
* | |
* | |
* Note that it's a very basic and simple implementation, it blocks ghost click on the same element where it was bound. | |
* If you need something more advanced, use plugin by FT Labs https://github.com/ftlabs/fastclick | |
* | |
*/ | |
(function() { | |
var ghostClickDelay = 1000, | |
supportsTouch = 'ontouchstart' in window, | |
unbindTouchMove = function() { | |
_window.off('touchmove'+ns+' touchend'+ns); | |
}, | |
eName = 'mfpFastClick', | |
ns = '.'+eName; | |
// As Zepto.js doesn't have an easy way to add custom events (like jQuery), so we implement it in this way | |
$.fn.mfpFastClick = function(callback) { | |
return $(this).each(function() { | |
var elem = $(this), | |
lock; | |
if( supportsTouch ) { | |
var timeout, | |
startX, | |
startY, | |
pointerMoved, | |
point, | |
numPointers; | |
elem.on('touchstart' + ns, function(e) { | |
pointerMoved = false; | |
numPointers = 1; | |
point = e.originalEvent ? e.originalEvent.touches[0] : e.touches[0]; | |
startX = point.clientX; | |
startY = point.clientY; | |
_window.on('touchmove'+ns, function(e) { | |
point = e.originalEvent ? e.originalEvent.touches : e.touches; | |
numPointers = point.length; | |
point = point[0]; | |
if (Math.abs(point.clientX - startX) > 10 || | |
Math.abs(point.clientY - startY) > 10) { | |
pointerMoved = true; | |
unbindTouchMove(); | |
} | |
}).on('touchend'+ns, function(e) { | |
unbindTouchMove(); | |
if(pointerMoved || numPointers > 1) { | |
return; | |
} | |
lock = true; | |
e.preventDefault(); | |
clearTimeout(timeout); | |
timeout = setTimeout(function() { | |
lock = false; | |
}, ghostClickDelay); | |
callback(); | |
}); | |
}); | |
} | |
elem.on('click' + ns, function() { | |
if(!lock) { | |
callback(); | |
} | |
}); | |
}); | |
}; | |
$.fn.destroyMfpFastClick = function() { | |
$(this).off('touchstart' + ns + ' click' + ns); | |
if(supportsTouch) _window.off('touchmove'+ns+' touchend'+ns); | |
}; | |
})(); | |
/*>>fastclick*/ | |
_checkInstance(); })); |