| /*! |
| * 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)); |
