1310 lines
29 KiB
JavaScript
1310 lines
29 KiB
JavaScript
/*!
|
|
* fancyBox - jQuery Plugin
|
|
* version: 2.0.4 (12/12/2011)
|
|
* @requires jQuery v1.6 or later
|
|
*
|
|
* Examples at http://fancyapps.com/fancybox/
|
|
* License: www.fancyapps.com/fancybox/#license
|
|
*
|
|
* Copyright 2011 Janis Skarnelis - janis@fancyapps.com
|
|
*
|
|
*/
|
|
(function (window, document, $) {
|
|
var W = $(window),
|
|
D = $(document),
|
|
F = $.fancybox = function () {
|
|
F.open.apply( this, arguments );
|
|
},
|
|
didResize = false,
|
|
resizeTimer = null;
|
|
|
|
$.extend(F, {
|
|
// The current version of fancyBox
|
|
version: '2.0.4',
|
|
|
|
defaults: {
|
|
padding: 15,
|
|
margin: 20,
|
|
|
|
width: 800,
|
|
height: 600,
|
|
minWidth: 200,
|
|
minHeight: 200,
|
|
maxWidth: 9999,
|
|
maxHeight: 9999,
|
|
|
|
autoSize: true,
|
|
fitToView: true,
|
|
aspectRatio: false,
|
|
topRatio: 0.5,
|
|
|
|
fixed: !$.browser.msie || $.browser.version > 6 || !document.documentElement.hasOwnProperty('ontouchstart'),
|
|
scrolling: 'auto', // 'auto', 'yes' or 'no'
|
|
wrapCSS: 'fancybox-default',
|
|
|
|
arrows: true,
|
|
closeBtn: true,
|
|
closeClick: false,
|
|
nextClick : false,
|
|
mouseWheel: true,
|
|
autoPlay: false,
|
|
playSpeed: 3000,
|
|
|
|
modal: false,
|
|
loop: true,
|
|
ajax: {},
|
|
keys: {
|
|
next: [13, 32, 34, 39, 40], // enter, space, page down, right arrow, down arrow
|
|
prev: [8, 33, 37, 38], // backspace, page up, left arrow, up arrow
|
|
close: [27] // escape key
|
|
},
|
|
|
|
// Override some properties
|
|
index: 0,
|
|
type: null,
|
|
href: null,
|
|
content: null,
|
|
title: null,
|
|
|
|
// HTML templates
|
|
tpl: {
|
|
wrap: '<div class="fancybox-wrap"><div class="fancybox-outer"><div class="fancybox-inner"></div></div></div>',
|
|
image: '<img class="fancybox-image" src="{href}" alt="" />',
|
|
iframe: '<iframe class="fancybox-iframe" name="fancybox-frame{rnd}" frameborder="0" hspace="0" ' + ($.browser.msie ? 'allowtransparency="true""' : '') + ' scrolling="{scrolling}" src="{href}"></iframe>',
|
|
swf: '<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="100%" height="100%"><param name="wmode" value="transparent" /><param name="allowfullscreen" value="true" /><param name="allowscriptaccess" value="always" /><param name="movie" value="{href}" /><embed src="{href}" type="application/x-shockwave-flash" allowfullscreen="true" allowscriptaccess="always" width="100%" height="100%" wmode="transparent"></embed></object>',
|
|
error: '<p class="fancybox-error">The requested content cannot be loaded.<br/>Please try again later.</p>',
|
|
closeBtn: '<div title="Close" class="fancybox-item fancybox-close"></div>',
|
|
next: '<a title="Next" class="fancybox-item fancybox-next"><span></span></a>',
|
|
prev: '<a title="Previous" class="fancybox-item fancybox-prev"><span></span></a>'
|
|
},
|
|
|
|
// Properties for each animation type
|
|
// Opening fancyBox
|
|
openEffect: 'fade', // 'elastic', 'fade' or 'none'
|
|
openSpeed: 250,
|
|
openEasing: 'swing',
|
|
openOpacity: true,
|
|
openMethod: 'zoomIn',
|
|
|
|
// Closing fancyBox
|
|
closeEffect: 'fade', // 'elastic', 'fade' or 'none'
|
|
closeSpeed: 250,
|
|
closeEasing: 'swing',
|
|
closeOpacity: true,
|
|
closeMethod: 'zoomOut',
|
|
|
|
// Changing next gallery item
|
|
nextEffect: 'elastic', // 'elastic', 'fade' or 'none'
|
|
nextSpeed: 300,
|
|
nextEasing: 'swing',
|
|
nextMethod: 'changeIn',
|
|
|
|
// Changing previous gallery item
|
|
prevEffect: 'elastic', // 'elastic', 'fade' or 'none'
|
|
prevSpeed: 300,
|
|
prevEasing: 'swing',
|
|
prevMethod: 'changeOut',
|
|
|
|
// Enabled helpers
|
|
helpers: {
|
|
overlay: {
|
|
speedIn: 0,
|
|
speedOut: 300,
|
|
opacity: 0.8,
|
|
css: {
|
|
cursor: 'pointer'
|
|
},
|
|
closeClick: true
|
|
},
|
|
title: {
|
|
type: 'float' // 'float', 'inside', 'outside' or 'over'
|
|
}
|
|
},
|
|
|
|
// Callbacks
|
|
onCancel: $.noop, // If canceling
|
|
beforeLoad: $.noop, // Before loading
|
|
afterLoad: $.noop, // After loading
|
|
beforeShow: $.noop, // Before changing in current item
|
|
afterShow: $.noop, // After opening
|
|
beforeClose: $.noop, // Before closing
|
|
afterClose: $.noop // After closing
|
|
},
|
|
|
|
//Current state
|
|
group: {}, // Selected group
|
|
opts: {}, // Group options
|
|
coming: null, // Element being loaded
|
|
current: null, // Currently loaded element
|
|
isOpen: false, // Is currently open
|
|
isOpened: false, // Have been fully opened at least once
|
|
wrap: null,
|
|
outer: null,
|
|
inner: null,
|
|
|
|
player: {
|
|
timer: null,
|
|
isActive: false
|
|
},
|
|
|
|
// Loaders
|
|
ajaxLoad: null,
|
|
imgPreload: null,
|
|
|
|
// Some collections
|
|
transitions: {},
|
|
helpers: {},
|
|
|
|
/*
|
|
* Static methods
|
|
*/
|
|
|
|
open: function (group, opts) {
|
|
// Normalize group
|
|
if (!$.isArray(group)) {
|
|
group = [group];
|
|
}
|
|
|
|
if (!group.length) {
|
|
return;
|
|
}
|
|
|
|
//Kill existing instances
|
|
F.close(true);
|
|
|
|
//Extend the defaults
|
|
F.opts = $.extend(true, {}, F.defaults, opts);
|
|
F.group = group;
|
|
|
|
F._start(F.opts.index || 0);
|
|
},
|
|
|
|
cancel: function () {
|
|
if (F.coming && false === F.trigger('onCancel')) {
|
|
return;
|
|
}
|
|
|
|
F.coming = null;
|
|
|
|
F.hideLoading();
|
|
|
|
if (F.ajaxLoad) {
|
|
F.ajaxLoad.abort();
|
|
}
|
|
|
|
F.ajaxLoad = null;
|
|
|
|
if (F.imgPreload) {
|
|
F.imgPreload.onload = F.imgPreload.onabort = F.imgPreload.onerror = null;
|
|
}
|
|
},
|
|
|
|
close: function (a) {
|
|
F.cancel();
|
|
|
|
if (!F.current || false === F.trigger('beforeClose')) {
|
|
return;
|
|
}
|
|
|
|
F.unbindEvents();
|
|
|
|
//If forced or is still opening then remove immediately
|
|
if (!F.isOpen || (a && a[0] === true)) {
|
|
$(".fancybox-wrap").stop().trigger('onReset').remove();
|
|
|
|
F._afterZoomOut();
|
|
|
|
} else {
|
|
F.isOpen = F.isOpened = false;
|
|
|
|
$(".fancybox-item").remove();
|
|
|
|
F.wrap.stop(true).removeClass('fancybox-opened');
|
|
F.inner.css('overflow', 'hidden');
|
|
|
|
F.transitions[F.current.closeMethod]();
|
|
}
|
|
},
|
|
|
|
// Start/stop slideshow
|
|
play: function (a) {
|
|
var clear = function () {
|
|
clearTimeout(F.player.timer);
|
|
},
|
|
set = function () {
|
|
clear();
|
|
|
|
if (F.current && F.player.isActive) {
|
|
F.player.timer = setTimeout(F.next, F.current.playSpeed);
|
|
}
|
|
},
|
|
stop = function () {
|
|
clear();
|
|
|
|
$('body').unbind('.player');
|
|
|
|
F.player.isActive = false;
|
|
|
|
F.trigger('onPlayEnd');
|
|
},
|
|
start = function () {
|
|
if (F.current && (F.current.loop || F.current.index < F.group.length - 1)) {
|
|
F.player.isActive = true;
|
|
|
|
$('body').bind({
|
|
'afterShow.player onUpdate.player': set,
|
|
'onCancel.player beforeClose.player': stop,
|
|
'beforeLoad.player': clear
|
|
});
|
|
|
|
set();
|
|
|
|
F.trigger('onPlayStart');
|
|
}
|
|
};
|
|
|
|
if (F.player.isActive || (a && a[0] === false)) {
|
|
stop();
|
|
} else {
|
|
start();
|
|
}
|
|
},
|
|
|
|
next: function () {
|
|
if (F.current) {
|
|
F.jumpto(F.current.index + 1);
|
|
}
|
|
},
|
|
|
|
prev: function () {
|
|
if (F.current) {
|
|
F.jumpto(F.current.index - 1);
|
|
}
|
|
},
|
|
|
|
jumpto: function (index) {
|
|
if (!F.current) {
|
|
return;
|
|
}
|
|
|
|
index = parseInt(index, 10);
|
|
|
|
if (F.group.length > 1 && F.current.loop) {
|
|
if (index >= F.group.length) {
|
|
index = 0;
|
|
|
|
} else if (index < 0) {
|
|
index = F.group.length - 1;
|
|
}
|
|
}
|
|
|
|
if (typeof F.group[index] !== 'undefined') {
|
|
F.cancel();
|
|
|
|
F._start(index);
|
|
}
|
|
},
|
|
|
|
reposition: function (a) {
|
|
if (F.isOpen) {
|
|
F.wrap.css(F._getPosition(a));
|
|
}
|
|
},
|
|
|
|
update: function () {
|
|
if (F.isOpen) {
|
|
// It's a very bad idea to attach handlers to the window scroll event, run this code after a delay
|
|
if (!didResize) {
|
|
resizeTimer = setInterval(function () {
|
|
if (didResize) {
|
|
didResize = false;
|
|
|
|
clearTimeout(resizeTimer);
|
|
|
|
if (F.current) {
|
|
if (F.current.autoSize) {
|
|
F.inner.height('auto');
|
|
F.current.height = F.inner.height();
|
|
}
|
|
|
|
F._setDimension();
|
|
|
|
if (F.current.canGrow) {
|
|
F.inner.height('auto');
|
|
}
|
|
|
|
F.reposition();
|
|
|
|
F.trigger('onUpdate');
|
|
}
|
|
}
|
|
}, 100);
|
|
}
|
|
|
|
didResize = true;
|
|
}
|
|
},
|
|
|
|
toggle: function () {
|
|
if (F.isOpen) {
|
|
F.current.fitToView = !F.current.fitToView;
|
|
|
|
F.update();
|
|
}
|
|
},
|
|
|
|
hideLoading: function () {
|
|
$("#fancybox-loading").remove();
|
|
},
|
|
|
|
showLoading: function () {
|
|
F.hideLoading();
|
|
|
|
$('<div id="fancybox-loading"></div>').click(F.cancel).appendTo('body');
|
|
},
|
|
|
|
getViewport: function () {
|
|
return {
|
|
x: W.scrollLeft(),
|
|
y: W.scrollTop(),
|
|
w: W.width(),
|
|
h: W.height()
|
|
};
|
|
},
|
|
|
|
// Unbind the keyboard / clicking actions
|
|
unbindEvents: function () {
|
|
if (F.wrap) {
|
|
F.wrap.unbind('.fb');
|
|
}
|
|
|
|
D.unbind('.fb');
|
|
W.unbind('.fb');
|
|
},
|
|
|
|
bindEvents: function () {
|
|
var current = F.current,
|
|
keys = current.keys;
|
|
|
|
if (!current) {
|
|
return;
|
|
}
|
|
|
|
W.bind('resize.fb, orientationchange.fb', F.update);
|
|
|
|
if (keys) {
|
|
D.bind('keydown.fb', function (e) {
|
|
var code;
|
|
|
|
// Ignore key combinations and key events within form elements
|
|
if (!e.ctrlKey && !e.altKey && !e.shiftKey && !e.metaKey && $.inArray(e.target.tagName.toLowerCase(), ['input', 'textarea', 'select', 'button']) < 0) {
|
|
code = e.keyCode;
|
|
|
|
if ($.inArray(code, keys.close) > -1) {
|
|
F.close();
|
|
e.preventDefault();
|
|
|
|
} else if ($.inArray(code, keys.next) > -1) {
|
|
F.next();
|
|
e.preventDefault();
|
|
|
|
} else if ($.inArray(code, keys.prev) > -1) {
|
|
F.prev();
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
if ($.fn.mousewheel && current.mouseWheel && F.group.length > 1) {
|
|
F.wrap.bind('mousewheel.fb', function (e, delta) {
|
|
var target = $(e.target).get(0);
|
|
|
|
if (target.clientHeight === 0 || target.scrollHeight === target.clientHeight) {
|
|
e.preventDefault();
|
|
|
|
F[delta > 0 ? 'prev' : 'next']();
|
|
}
|
|
});
|
|
}
|
|
},
|
|
|
|
trigger: function (event) {
|
|
var ret, obj = F[ $.inArray(event, ['onCancel', 'beforeLoad', 'afterLoad']) > -1 ? 'coming' : 'current' ];
|
|
|
|
if (!obj) {
|
|
return;
|
|
}
|
|
|
|
if ($.isFunction( obj[event] )) {
|
|
ret = obj[event].apply(obj, Array.prototype.slice.call(arguments, 1));
|
|
}
|
|
|
|
if (ret === false) {
|
|
return false;
|
|
}
|
|
|
|
if (obj.helpers) {
|
|
$.each(obj.helpers, function (helper, opts) {
|
|
if (opts && typeof F.helpers[helper] !== 'undefined' && $.isFunction(F.helpers[helper][event])) {
|
|
F.helpers[helper][event](opts, obj);
|
|
}
|
|
});
|
|
}
|
|
|
|
$.event.trigger(event + '.fb');
|
|
},
|
|
|
|
isImage: function (str) {
|
|
return str && str.match(/\.(jpg|gif|png|bmp|jpeg)(.*)?$/i);
|
|
},
|
|
|
|
isSWF: function (str) {
|
|
return str && str.match(/\.(swf)(.*)?$/i);
|
|
},
|
|
|
|
_start: function (index) {
|
|
var coming = {},
|
|
element = F.group[index] || null,
|
|
isDom,
|
|
href,
|
|
type,
|
|
rez;
|
|
|
|
if (typeof element === 'object' && (element.nodeType || element instanceof $)) {
|
|
isDom = true;
|
|
|
|
if ($.metadata) {
|
|
coming = $(element).metadata();
|
|
}
|
|
}
|
|
|
|
coming = $.extend(true, {}, F.opts, {index : index, element : element}, ($.isPlainObject(element) ? element : coming));
|
|
|
|
// Re-check overridable options
|
|
$.each(['href', 'title', 'content', 'type'], function(i,v) {
|
|
coming[v] = F.opts[ v ] || (isDom && $(element).attr( v )) || coming[ v ] || null;
|
|
});
|
|
|
|
// Convert margin property to array - top, right, bottom, left
|
|
if (typeof coming.margin === 'number') {
|
|
coming.margin = [coming.margin, coming.margin, coming.margin, coming.margin];
|
|
}
|
|
|
|
// 'modal' propery is just a shortcut
|
|
if (coming.modal) {
|
|
$.extend(true, coming, {
|
|
closeBtn : false,
|
|
closeClick: false,
|
|
nextClick : false,
|
|
arrows : false,
|
|
mouseWheel : false,
|
|
keys : null,
|
|
helpers: {
|
|
overlay : {
|
|
css: {
|
|
cursor : 'auto'
|
|
},
|
|
closeClick : false
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
//Give a chance for callback or helpers to update coming item (type, title, etc)
|
|
F.coming = coming;
|
|
|
|
if (false === F.trigger('beforeLoad')) {
|
|
F.coming = null;
|
|
return;
|
|
}
|
|
|
|
type = coming.type;
|
|
href = coming.href;
|
|
|
|
///Check if content type is set, if not, try to get
|
|
if (!type) {
|
|
if (isDom) {
|
|
rez = $(element).data('fancybox-type');
|
|
|
|
if (!rez && element.className) {
|
|
rez = element.className.match(/fancybox\.(\w+)/);
|
|
type = rez ? rez[1] : null;
|
|
}
|
|
}
|
|
|
|
if (!type && href) {
|
|
if (F.isImage(href)) {
|
|
type = 'image';
|
|
|
|
} else if (F.isSWF(href)) {
|
|
type = 'swf';
|
|
|
|
} else if (href.match(/^#/)) {
|
|
type = 'inline';
|
|
}
|
|
}
|
|
|
|
// ...if not - display element itself
|
|
if (!type) {
|
|
type = isDom ? 'inline' : 'html';
|
|
}
|
|
|
|
coming.type = type;
|
|
}
|
|
|
|
// Check before try to load; 'inline' and 'html' types need content, others - href
|
|
if (type === 'inline' || type === 'html') {
|
|
coming.content = coming.content || (type === 'inline' && href ? $(href) : element);
|
|
|
|
if (!coming.content.length) {
|
|
type = null;
|
|
}
|
|
|
|
} else {
|
|
coming.href = href || element;
|
|
|
|
if (!coming.href) {
|
|
type = null;
|
|
}
|
|
}
|
|
|
|
/*
|
|
Add reference to the group, so it`s possible to access from callbacks, example:
|
|
|
|
afterLoad : function() {
|
|
this.title = 'Image ' + (this.index + 1) + ' of ' + this.group.length + (this.title ? ' - ' + this.title : '');
|
|
}
|
|
|
|
*/
|
|
|
|
coming.group = F.group;
|
|
|
|
if (type === 'image') {
|
|
F._loadImage();
|
|
|
|
} else if (type === 'ajax') {
|
|
F._loadAjax();
|
|
|
|
} else if (type) {
|
|
F._afterLoad();
|
|
|
|
} else {
|
|
F._error( 'type' );
|
|
}
|
|
},
|
|
|
|
_error: function ( type ) {
|
|
$.extend(F.coming, {
|
|
type : 'html',
|
|
autoSize : true,
|
|
minHeight : '0',
|
|
hasError : type,
|
|
content : F.coming.tpl.error
|
|
});
|
|
|
|
F._afterLoad();
|
|
},
|
|
|
|
_loadImage: function () {
|
|
// Reset preload image so it is later possible to check "complete" property
|
|
F.imgPreload = new Image();
|
|
|
|
F.imgPreload.onload = function () {
|
|
this.onload = this.onerror = null;
|
|
|
|
F.coming.width = this.width;
|
|
F.coming.height = this.height;
|
|
|
|
F._afterLoad();
|
|
};
|
|
|
|
F.imgPreload.onerror = function () {
|
|
this.onload = this.onerror = null;
|
|
|
|
F._error( 'image' );
|
|
};
|
|
|
|
F.imgPreload.src = F.coming.href;
|
|
|
|
if (!F.imgPreload.complete) {
|
|
F.showLoading();
|
|
}
|
|
},
|
|
|
|
_loadAjax: function () {
|
|
F.showLoading();
|
|
|
|
F.ajaxLoad = $.ajax($.extend({}, F.coming.ajax, {
|
|
url: F.coming.href,
|
|
error: function (jqXHR, textStatus) {
|
|
if (textStatus !== 'abort') {
|
|
F._error( 'ajax', jqXHR );
|
|
|
|
} else {
|
|
F.hideLoading();
|
|
}
|
|
},
|
|
success: function (data, textStatus) {
|
|
if (textStatus === 'success') {
|
|
F.coming.content = data;
|
|
|
|
F._afterLoad();
|
|
}
|
|
}
|
|
}));
|
|
},
|
|
|
|
_preload : function() {
|
|
var group = F.group,
|
|
index = F.current.index,
|
|
load = function(href) {
|
|
if (href && F.isImage(href)) {
|
|
new Image().src = href;
|
|
}
|
|
};
|
|
|
|
if (group.length > 1) {
|
|
load( $( group[ index + 1 ] || group[ 0 ] ).attr('href') );
|
|
load( $( group[ index - 1 ] || group[ group.length - 1 ] ).attr('href') );
|
|
}
|
|
},
|
|
|
|
_afterLoad: function () {
|
|
F.hideLoading();
|
|
|
|
if (!F.coming || false === F.trigger('afterLoad', F.current)) {
|
|
F.coming = false;
|
|
|
|
return;
|
|
}
|
|
|
|
if (F.isOpened) {
|
|
$(".fancybox-item").remove();
|
|
|
|
F.wrap.stop(true).removeClass('fancybox-opened');
|
|
F.inner.css('overflow', 'hidden');
|
|
|
|
F.transitions[F.current.prevMethod]();
|
|
|
|
} else {
|
|
$(".fancybox-wrap").stop().trigger('onReset').remove();
|
|
|
|
F.trigger('afterClose');
|
|
}
|
|
|
|
F.unbindEvents();
|
|
|
|
F.isOpen = false;
|
|
F.current = F.coming;
|
|
F.coming = false;
|
|
|
|
//Build the neccessary markup
|
|
F.wrap = $(F.current.tpl.wrap).addClass('fancybox-tmp ' + F.current.wrapCSS).appendTo('body');
|
|
F.outer = $('.fancybox-outer', F.wrap).css('padding', F.current.padding + 'px');
|
|
F.inner = $('.fancybox-inner', F.wrap);
|
|
|
|
F._setContent();
|
|
|
|
//Give a chance for helpers or callbacks to update elements
|
|
F.trigger('beforeShow');
|
|
|
|
//Set initial dimensions and hide
|
|
F._setDimension();
|
|
|
|
F.wrap.hide().removeClass('fancybox-tmp');
|
|
|
|
F.bindEvents();
|
|
F._preload();
|
|
|
|
F.transitions[ F.isOpened ? F.current.nextMethod : F.current.openMethod ]();
|
|
},
|
|
|
|
_setContent: function () {
|
|
var content, loadingBay, current = F.current,
|
|
type = current.type;
|
|
|
|
switch (type) {
|
|
case 'inline':
|
|
case 'ajax':
|
|
case 'html':
|
|
content = current.content;
|
|
|
|
if (type === 'inline' && content instanceof $) {
|
|
content = content.show().detach();
|
|
|
|
if (content.parent().hasClass('fancybox-inner')) {
|
|
content.parents('.fancybox-wrap').trigger('onReset').remove();
|
|
}
|
|
|
|
$(F.wrap).bind('onReset', function () {
|
|
content.appendTo('body').hide();
|
|
});
|
|
}
|
|
|
|
if (current.autoSize) {
|
|
loadingBay = $('<div class="fancybox-tmp"></div>').appendTo($("body")).append(content);
|
|
|
|
current.width = loadingBay.outerWidth();
|
|
current.height = loadingBay.outerHeight(true);
|
|
|
|
content = loadingBay.contents().detach();
|
|
|
|
loadingBay.remove();
|
|
}
|
|
|
|
break;
|
|
|
|
case 'image':
|
|
content = current.tpl.image.replace('{href}', current.href);
|
|
|
|
current.aspectRatio = true;
|
|
break;
|
|
|
|
case 'swf':
|
|
content = current.tpl.swf.replace(/\{width\}/g, current.width).replace(/\{height\}/g, current.height).replace(/\{href\}/g, current.href);
|
|
break;
|
|
|
|
case 'iframe':
|
|
content = current.tpl.iframe.replace('{href}', current.href).replace('{scrolling}', current.scrolling).replace('{rnd}', new Date().getTime());
|
|
break;
|
|
}
|
|
|
|
if ($.inArray(type, ['image', 'swf', 'iframe']) > -1) {
|
|
current.autoSize = false;
|
|
current.scrolling = false;
|
|
}
|
|
|
|
F.inner.append(content);
|
|
},
|
|
|
|
_setDimension: function () {
|
|
var wrap = F.wrap,
|
|
outer = F.outer,
|
|
inner = F.inner,
|
|
current = F.current,
|
|
viewport = F.getViewport(),
|
|
margin = current.margin,
|
|
padding2 = current.padding * 2,
|
|
width = current.width + padding2,
|
|
height = current.height + padding2,
|
|
ratio = current.width / current.height,
|
|
|
|
maxWidth = current.maxWidth,
|
|
maxHeight = current.maxHeight,
|
|
minWidth = current.minWidth,
|
|
minHeight = current.minHeight,
|
|
height_,
|
|
space;
|
|
|
|
viewport.w -= (margin[1] + margin[3]);
|
|
viewport.h -= (margin[0] + margin[2]);
|
|
|
|
if (width.toString().indexOf('%') > -1) {
|
|
width = ((viewport.w * parseFloat(width)) / 100);
|
|
}
|
|
|
|
if (height.toString().indexOf('%') > -1) {
|
|
height = ((viewport.h * parseFloat(height)) / 100);
|
|
}
|
|
|
|
if (current.fitToView) {
|
|
maxWidth = Math.min(viewport.w, maxWidth);
|
|
maxHeight = Math.min(viewport.h, maxHeight);
|
|
}
|
|
|
|
minWidth = Math.min(width, minWidth);
|
|
minHeight = Math.min(width, minHeight);
|
|
|
|
maxWidth = Math.max(minWidth, maxWidth);
|
|
maxHeight = Math.max(minHeight, maxHeight);
|
|
|
|
if (current.aspectRatio) {
|
|
if (width > maxWidth) {
|
|
width = maxWidth;
|
|
height = ((width - padding2) / ratio) + padding2;
|
|
}
|
|
|
|
if (height > maxHeight) {
|
|
height = maxHeight;
|
|
width = ((height - padding2) * ratio) + padding2;
|
|
}
|
|
|
|
if (width < minWidth) {
|
|
width = minWidth;
|
|
height = ((width - padding2) / ratio) + padding2;
|
|
}
|
|
|
|
if (height < minHeight) {
|
|
height = minHeight;
|
|
width = ((height - padding2) * ratio) + padding2;
|
|
}
|
|
|
|
} else {
|
|
width = Math.max(minWidth, Math.min(width, maxWidth));
|
|
height = Math.max(minHeight, Math.min(height, maxHeight));
|
|
}
|
|
|
|
width = Math.round(width);
|
|
height = Math.round(height);
|
|
|
|
//Reset dimensions
|
|
$(wrap.add(outer).add(inner)).width('auto').height('auto');
|
|
|
|
inner.width(width - padding2).height(height - padding2);
|
|
wrap.width(width);
|
|
|
|
height_ = wrap.height(); // Real wrap height
|
|
|
|
//Fit wrapper inside
|
|
if (width > maxWidth || height_ > maxHeight) {
|
|
while ((width > maxWidth || height_ > maxHeight) && width > minWidth && height_ > minHeight) {
|
|
height = height - 10;
|
|
|
|
if (current.aspectRatio) {
|
|
width = Math.round(((height - padding2) * ratio) + padding2);
|
|
|
|
if (width < minWidth) {
|
|
width = minWidth;
|
|
height = ((width - padding2) / ratio) + padding2;
|
|
}
|
|
|
|
} else {
|
|
width = width - 10;
|
|
}
|
|
|
|
inner.width(width - padding2).height(height - padding2);
|
|
wrap.width(width);
|
|
|
|
height_ = wrap.height();
|
|
}
|
|
}
|
|
|
|
current.dim = {
|
|
width: width,
|
|
height: height_
|
|
};
|
|
|
|
current.canGrow = current.autoSize && height > minHeight && height < maxHeight;
|
|
current.canShrink = false;
|
|
current.canExpand = false;
|
|
|
|
if ((width - padding2) < current.width || (height - padding2) < current.height) {
|
|
current.canExpand = true;
|
|
|
|
} else if ((width > viewport.w || height_ > viewport.h) && width > minWidth && height > minHeight) {
|
|
current.canShrink = true;
|
|
}
|
|
|
|
space = height_ - padding2;
|
|
|
|
F.innerSpace = space - inner.height();
|
|
F.outerSpace = space - outer.height();
|
|
},
|
|
|
|
_getPosition: function (a) {
|
|
var current = F.current,
|
|
viewport = F.getViewport(),
|
|
margin = current.margin,
|
|
width = F.wrap.width() + margin[1] + margin[3],
|
|
height = F.wrap.height() + margin[0] + margin[2],
|
|
rez = {
|
|
position: 'absolute',
|
|
top: margin[0] + viewport.y,
|
|
left: margin[3] + viewport.x
|
|
};
|
|
|
|
if (current.fixed && (!a || a[0] === false) && height <= viewport.h && width <= viewport.w) {
|
|
rez = {
|
|
position: 'fixed',
|
|
top: margin[0],
|
|
left: margin[3]
|
|
};
|
|
}
|
|
|
|
rez.top = Math.ceil(Math.max(rez.top, rez.top + ((viewport.h - height) * current.topRatio))) + 'px';
|
|
rez.left = Math.ceil(Math.max(rez.left, rez.left + ((viewport.w - width) * 0.5))) + 'px';
|
|
|
|
return rez;
|
|
},
|
|
|
|
_afterZoomIn: function () {
|
|
var current = F.current;
|
|
|
|
F.isOpen = F.isOpened = true;
|
|
|
|
F.wrap.addClass('fancybox-opened').css('overflow', 'visible');
|
|
|
|
F.update();
|
|
|
|
F.inner.css('overflow', current.scrolling === 'auto' ? 'auto' : (current.scrolling === 'yes' ? 'scroll' : 'hidden'));
|
|
|
|
//Assign a click event
|
|
if (current.closeClick || current.nextClick) {
|
|
F.inner.css('cursor', 'pointer').bind('click.fb', current.nextClick ? F.next : F.close);
|
|
}
|
|
|
|
//Create a close button
|
|
if (current.closeBtn) {
|
|
$(current.tpl.closeBtn).appendTo(F.wrap).bind('click.fb', F.close);
|
|
}
|
|
|
|
//Create navigation arrows
|
|
if (current.arrows && F.group.length > 1) {
|
|
if (current.loop || current.index > 0) {
|
|
$(current.tpl.prev).appendTo(F.wrap).bind('click.fb', F.prev);
|
|
}
|
|
|
|
if (current.loop || current.index < F.group.length - 1) {
|
|
$(current.tpl.next).appendTo(F.wrap).bind('click.fb', F.next);
|
|
}
|
|
}
|
|
|
|
F.trigger('afterShow');
|
|
|
|
if (F.opts.autoPlay && !F.player.isActive) {
|
|
F.opts.autoPlay = false;
|
|
|
|
F.play();
|
|
}
|
|
},
|
|
|
|
_afterZoomOut: function () {
|
|
F.trigger('afterClose');
|
|
|
|
F.wrap.trigger('onReset').remove();
|
|
|
|
$.extend(F, {
|
|
group: {},
|
|
opts: {},
|
|
current: null,
|
|
isOpened: false,
|
|
isOpen: false,
|
|
wrap: null,
|
|
outer: null,
|
|
inner: null
|
|
});
|
|
}
|
|
});
|
|
|
|
/*
|
|
* Default transitions
|
|
*/
|
|
|
|
F.transitions = {
|
|
getOrigPosition: function () {
|
|
var element = F.current.element,
|
|
pos = {},
|
|
width = 50,
|
|
height = 50,
|
|
image, viewport;
|
|
|
|
if (element && element.nodeName && $(element).is(':visible')) {
|
|
image = $(element).find('img:first');
|
|
|
|
if (image.length) {
|
|
pos = image.offset();
|
|
width = image.outerWidth();
|
|
height = image.outerHeight();
|
|
|
|
} else {
|
|
pos = $(element).offset();
|
|
}
|
|
|
|
} else {
|
|
viewport = F.getViewport();
|
|
pos.top = viewport.y + (viewport.h - height) * 0.5;
|
|
pos.left = viewport.x + (viewport.w - width) * 0.5;
|
|
}
|
|
|
|
pos = {
|
|
top: Math.ceil(pos.top) + 'px',
|
|
left: Math.ceil(pos.left) + 'px',
|
|
width: Math.ceil(width) + 'px',
|
|
height: Math.ceil(height) + 'px'
|
|
};
|
|
|
|
return pos;
|
|
},
|
|
|
|
step: function (now, fx) {
|
|
var ratio, innerValue, outerValue;
|
|
|
|
if (fx.prop === 'width' || fx.prop === 'height') {
|
|
innerValue = outerValue = Math.ceil(now - (F.current.padding * 2));
|
|
|
|
if (fx.prop === 'height') {
|
|
ratio = (now - fx.start) / (fx.end - fx.start);
|
|
|
|
if (fx.start > fx.end) {
|
|
ratio = 1 - ratio;
|
|
}
|
|
|
|
innerValue -= F.innerSpace * ratio;
|
|
outerValue -= F.outerSpace * ratio;
|
|
}
|
|
|
|
F.inner[fx.prop](innerValue);
|
|
F.outer[fx.prop](outerValue);
|
|
}
|
|
},
|
|
|
|
zoomIn: function () {
|
|
var wrap = F.wrap,
|
|
current = F.current,
|
|
startPos,
|
|
endPos,
|
|
dim = current.dim;
|
|
|
|
if (current.openEffect === 'elastic') {
|
|
endPos = $.extend({}, dim, F._getPosition(true));
|
|
|
|
//Remove "position" property
|
|
delete endPos.position;
|
|
|
|
startPos = this.getOrigPosition();
|
|
|
|
if (current.openOpacity) {
|
|
startPos.opacity = 0;
|
|
endPos.opacity = 1;
|
|
}
|
|
|
|
wrap.css(startPos).show().animate(endPos, {
|
|
duration: current.openSpeed,
|
|
easing: current.openEasing,
|
|
step: this.step,
|
|
complete: F._afterZoomIn
|
|
});
|
|
|
|
} else {
|
|
wrap.css($.extend({}, dim, F._getPosition()));
|
|
|
|
if (current.openEffect === 'fade') {
|
|
wrap.fadeIn(current.openSpeed, F._afterZoomIn);
|
|
|
|
} else {
|
|
wrap.show();
|
|
F._afterZoomIn();
|
|
}
|
|
}
|
|
},
|
|
|
|
zoomOut: function () {
|
|
var wrap = F.wrap,
|
|
current = F.current,
|
|
endPos;
|
|
|
|
if (current.closeEffect === 'elastic') {
|
|
if (wrap.css('position') === 'fixed') {
|
|
wrap.css(F._getPosition(true));
|
|
}
|
|
|
|
endPos = this.getOrigPosition();
|
|
|
|
if (current.closeOpacity) {
|
|
endPos.opacity = 0;
|
|
}
|
|
|
|
wrap.animate(endPos, {
|
|
duration: current.closeSpeed,
|
|
easing: current.closeEasing,
|
|
step: this.step,
|
|
complete: F._afterZoomOut
|
|
});
|
|
|
|
} else {
|
|
wrap.fadeOut(current.closeEffect === 'fade' ? current.closeSpeed : 0, F._afterZoomOut);
|
|
}
|
|
},
|
|
|
|
changeIn: function () {
|
|
var wrap = F.wrap,
|
|
current = F.current,
|
|
startPos;
|
|
|
|
if (current.nextEffect === 'elastic') {
|
|
startPos = F._getPosition(true);
|
|
startPos.opacity = 0;
|
|
startPos.top = (parseInt(startPos.top, 10) - 200) + 'px';
|
|
|
|
wrap.css(startPos).show().animate({
|
|
opacity: 1,
|
|
top: '+=200px'
|
|
}, {
|
|
duration: current.nextSpeed,
|
|
complete: F._afterZoomIn
|
|
});
|
|
|
|
} else {
|
|
wrap.css(F._getPosition());
|
|
|
|
if (current.nextEffect === 'fade') {
|
|
wrap.hide().fadeIn(current.nextSpeed, F._afterZoomIn);
|
|
|
|
} else {
|
|
wrap.show();
|
|
F._afterZoomIn();
|
|
}
|
|
}
|
|
},
|
|
|
|
changeOut: function () {
|
|
var wrap = F.wrap,
|
|
current = F.current,
|
|
cleanUp = function () {
|
|
$(this).trigger('onReset').remove();
|
|
};
|
|
|
|
wrap.removeClass('fancybox-opened');
|
|
|
|
if (current.prevEffect === 'elastic') {
|
|
wrap.animate({
|
|
'opacity': 0,
|
|
top: '+=200px'
|
|
}, {
|
|
duration: current.prevSpeed,
|
|
complete: cleanUp
|
|
});
|
|
|
|
} else {
|
|
wrap.fadeOut(current.prevEffect === 'fade' ? current.prevSpeed : 0, cleanUp);
|
|
}
|
|
}
|
|
};
|
|
|
|
/*
|
|
* Overlay helper
|
|
*/
|
|
|
|
F.helpers.overlay = {
|
|
overlay: null,
|
|
|
|
update: function () {
|
|
var width, scrollWidth, offsetWidth;
|
|
|
|
//Reset width/height so it will not mess
|
|
this.overlay.width(0).height(0);
|
|
|
|
if ($.browser.msie) {
|
|
scrollWidth = Math.max(document.documentElement.scrollWidth, document.body.scrollWidth);
|
|
offsetWidth = Math.max(document.documentElement.offsetWidth, document.body.offsetWidth);
|
|
|
|
width = scrollWidth < offsetWidth ? W.width() : scrollWidth;
|
|
|
|
} else {
|
|
width = D.width();
|
|
}
|
|
|
|
this.overlay.width(width).height(D.height());
|
|
},
|
|
|
|
beforeShow: function (opts) {
|
|
if (this.overlay) {
|
|
return;
|
|
}
|
|
|
|
this.overlay = $('<div id="fancybox-overlay"></div>').css(opts.css || {
|
|
background: 'black'
|
|
}).appendTo('body');
|
|
|
|
this.update();
|
|
|
|
if (opts.closeClick) {
|
|
this.overlay.bind('click.fb', F.close);
|
|
}
|
|
|
|
W.bind("resize.fb", $.proxy(this.update, this));
|
|
|
|
this.overlay.fadeTo(opts.speedIn || "fast", opts.opacity || 1);
|
|
},
|
|
|
|
onUpdate: function () {
|
|
//Update as content may change document dimensions
|
|
this.update();
|
|
},
|
|
|
|
afterClose: function (opts) {
|
|
if (this.overlay) {
|
|
this.overlay.fadeOut(opts.speedOut || "fast", function () {
|
|
$(this).remove();
|
|
});
|
|
}
|
|
|
|
this.overlay = null;
|
|
}
|
|
};
|
|
|
|
/*
|
|
* Title helper
|
|
*/
|
|
|
|
F.helpers.title = {
|
|
beforeShow: function (opts) {
|
|
var title, text = F.current.title;
|
|
|
|
if (text) {
|
|
title = $('<div class="fancybox-title fancybox-title-' + opts.type + '-wrap">' + text + '</div>').appendTo('body');
|
|
|
|
if (opts.type === 'float') {
|
|
//This helps for some browsers
|
|
title.width(title.width());
|
|
|
|
title.wrapInner('<span class="child"></span>');
|
|
|
|
//Increase bottom margin so this title will also fit into viewport
|
|
F.current.margin[2] += Math.abs(parseInt(title.css('margin-bottom'), 10));
|
|
}
|
|
|
|
title.appendTo(opts.type === 'over' ? F.inner : (opts.type === 'outside' ? F.wrap : F.outer));
|
|
}
|
|
}
|
|
};
|
|
|
|
// jQuery plugin initialization
|
|
$.fn.fancybox = function (options) {
|
|
var opts = options || {},
|
|
selector = this.selector || '';
|
|
|
|
function run(e) {
|
|
var group = [], relType, relVal, rel = this.rel;
|
|
|
|
if (!(e.ctrlKey || e.altKey || e.shiftKey || e.metaKey)) {
|
|
e.preventDefault();
|
|
|
|
relVal = $(this).data('fancybox-group');
|
|
|
|
// Check if element has 'data-fancybox-group' attribute, if not - use 'rel'
|
|
if (typeof relVal !== 'undefined') {
|
|
relType = relVal ? 'data-fancybox-group' : false;
|
|
|
|
} else if (rel && rel !== '' && rel !== 'nofollow') {
|
|
relVal = rel;
|
|
relType = 'rel';
|
|
}
|
|
|
|
if (relType) {
|
|
group = selector.length ? $(selector).filter('[' + relType + '="' + relVal + '"]') : $('[' + relType + '="' + relVal + '"]');
|
|
}
|
|
|
|
if (group.length) {
|
|
opts.index = group.index(this);
|
|
|
|
F.open(group.get(), opts);
|
|
|
|
} else {
|
|
F.open(this, opts);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (selector) {
|
|
D.undelegate(selector, 'click.fb-start').delegate(selector, 'click.fb-start', run);
|
|
|
|
} else {
|
|
$(this).unbind('click.fb-start').bind('click.fb-start', run);
|
|
}
|
|
|
|
return this;
|
|
};
|
|
|
|
}(window, document, jQuery)); |