###
# jQuery ezPlus 3.1.0
# Demo's and documentation:
# http://igorlino.github.io/elevatezoom-plus/
#
# Dual licensed under the GPL and MIT licenses.
# http://en.wikipedia.org/wiki/MIT_License
# http://en.wikipedia.org/wiki/GNU_General_Public_License
#
###
if typeof Object.create != 'function'
Object.create = (obj) ->
F = ->
F.prototype = obj
new F
(($, window, document) ->
EZP =
init: (options, elem) ->
self = this
self.elem = elem
self.$elem = $(elem)
self.imageSrc = if self.$elem.data('zoom-image') then self.$elem.data('zoom-image') else self.$elem.attr('src')
self.options = $.extend({}, $.fn.ezPlus.options, self.responsiveConfig(options or {}))
if !self.options.enabled
return
#TINT OVERRIDE SETTINGS
if self.options.tint
self.options.lensColour = 'none'
self.options.lensOpacity = '1'
#opacity of the lens
#INNER OVERRIDE SETTINGS
if self.options.zoomType == 'inner'
self.options.showLens = false
#Remove alt on hover
self.$elem.parent().removeAttr('title').removeAttr 'alt'
self.zoomImage = self.imageSrc
self.refresh 1
#Create the image swap from the gallery
$('#' + self.options.gallery + ' a').click (e) ->
#Set a class on the currently active gallery image
if self.options.galleryActiveClass
$('#' + self.options.gallery + ' a').removeClass self.options.galleryActiveClass
$(this).addClass self.options.galleryActiveClass
#stop any link on the a tag from working
e.preventDefault()
#call the swap image function
if $(this).data('zoom-image')
self.zoomImagePre = $(this).data('zoom-image')
else
self.zoomImagePre = $(this).data('image')
self.swaptheimage $(this).data('image'), self.zoomImagePre
false
return
refresh: (length) ->
self = this
setTimeout (->
self.fetch self.imageSrc
return
), length or self.options.refresh
return
fetch: (imgsrc) ->
#get the image
self = this
newImg = new Image
newImg.onload = ->
#set the large image dimensions - used to calculte ratio's
self.largeWidth = newImg.width
self.largeHeight = newImg.height
#once image is loaded start the calls
self.startZoom()
self.currentImage = self.imageSrc
#let caller know image has been loaded
self.options.onZoomedImageLoaded self.$elem
return
newImg.src = imgsrc
# this must be done AFTER setting onload
return
startZoom: ->
self = this
#get dimensions of the non zoomed image
self.nzWidth = self.$elem.width()
self.nzHeight = self.$elem.height()
#activated elements
self.isWindowActive = false
self.isLensActive = false
self.isTintActive = false
self.overWindow = false
#CrossFade Wrappe
if self.options.imageCrossfade
self.zoomWrap = self.$elem.wrap('')
self.$elem.css 'position', 'absolute'
self.zoomLock = 1
self.scrollingLock = false
self.changeBgSize = false
self.currentZoomLevel = self.options.zoomLevel
#get offset of the non zoomed image
self.nzOffset = self.$elem.offset()
#calculate the width ratio of the large/small image
self.widthRatio = self.largeWidth / self.currentZoomLevel / self.nzWidth
self.heightRatio = self.largeHeight / self.currentZoomLevel / self.nzHeight
#if window zoom
if self.options.zoomType == 'window'
self.zoomWindowStyle = 'overflow: hidden;' + 'background-position: 0px 0px;text-align:center;' + 'background-color: ' + String(self.options.zoomWindowBgColour) + ';width: ' + String(self.options.zoomWindowWidth) + 'px;' + 'height: ' + String(self.options.zoomWindowHeight) + 'px;float: left;' + 'background-size: ' + self.largeWidth / self.currentZoomLevel + 'px ' + self.largeHeight / self.currentZoomLevel + 'px;' + 'display: none;z-index:100;' + 'border: ' + String(self.options.borderSize) + 'px solid ' + self.options.borderColour + ';background-repeat: no-repeat;' + 'position: absolute;'
#if inner zoom
if self.options.zoomType == 'inner'
#has a border been put on the image? Lets cater for this
borderWidth = self.$elem.css('border-left-width')
self.zoomWindowStyle = 'overflow: hidden;' + 'margin-left: ' + String(borderWidth) + ';' + 'margin-top: ' + String(borderWidth) + ';' + 'background-position: 0px 0px;' + 'width: ' + String(self.nzWidth) + 'px;' + 'height: ' + String(self.nzHeight) + 'px;float: left;' + 'display: none;' + 'cursor:' + self.options.cursor + ';' + 'px solid ' + self.options.borderColour + ';background-repeat: no-repeat;' + 'position: absolute;'
#lens style for window zoom
if self.options.zoomType == 'window'
# adjust images less than the window height
if self.nzHeight < self.options.zoomWindowWidth / self.widthRatio
lensHeight = self.nzHeight
else
lensHeight = String(self.options.zoomWindowHeight / self.heightRatio)
if self.largeWidth < self.options.zoomWindowWidth
lensWidth = self.nzWidth
else
lensWidth = self.options.zoomWindowWidth / self.widthRatio
self.lensStyle = 'background-position: 0px 0px;width: ' + String(self.options.zoomWindowWidth / self.widthRatio) + 'px;height: ' + String(self.options.zoomWindowHeight / self.heightRatio) + 'px;float: right;display: none;' + 'overflow: hidden;' + 'z-index: 999;' + '-webkit-transform: translateZ(0);' + 'opacity:' + self.options.lensOpacity + ';filter: alpha(opacity = ' + self.options.lensOpacity * 100 + '); zoom:1;' + 'width:' + lensWidth + 'px;' + 'height:' + lensHeight + 'px;' + 'background-color:' + self.options.lensColour + ';' + 'cursor:' + self.options.cursor + ';' + 'border: ' + self.options.lensBorderSize + 'px' + ' solid ' + self.options.lensBorderColour + ';background-repeat: no-repeat;position: absolute;'
#tint style
self.tintStyle = 'display: block;' + 'position: absolute;' + 'background-color: ' + self.options.tintColour + ';' + 'filter:alpha(opacity=0);' + 'opacity: 0;' + 'width: ' + self.nzWidth + 'px;' + 'height: ' + self.nzHeight + 'px;'
#lens style for lens zoom with optional round for modern browsers
self.lensRound = ''
if self.options.zoomType == 'lens'
self.lensStyle = 'background-position: 0px 0px;' + 'float: left;display: none;' + 'border: ' + String(self.options.borderSize) + 'px solid ' + self.options.borderColour + ';' + 'width:' + String(self.options.lensSize) + 'px;' + 'height:' + String(self.options.lensSize) + 'px;' + 'background-repeat: no-repeat;position: absolute;'
#does not round in all browsers
if self.options.lensShape == 'round'
self.lensRound = 'border-top-left-radius: ' + String(self.options.lensSize / 2 + self.options.borderSize) + 'px;' + 'border-top-right-radius: ' + String(self.options.lensSize / 2 + self.options.borderSize) + 'px;' + 'border-bottom-left-radius: ' + String(self.options.lensSize / 2 + self.options.borderSize) + 'px;' + 'border-bottom-right-radius: ' + String(self.options.lensSize / 2 + self.options.borderSize) + 'px;'
#create the div's + ""
#self.zoomContainer = $('').addClass('zoomContainer').css({"position":"relative", "height":self.nzHeight, "width":self.nzWidth});
self.zoomContainer = $('')
$('body').append self.zoomContainer
#this will add overflow hidden and contrain the lens on lens mode
if self.options.containLensZoom and self.options.zoomType == 'lens'
self.zoomContainer.css 'overflow', 'hidden'
if self.options.zoomType != 'inner'
self.zoomLens = $('
').appendTo(self.zoomContainer).click(->
self.$elem.trigger 'click'
return
)
if self.options.tint
self.tintContainer = $('').addClass('tintContainer')
self.zoomTint = $('')
self.zoomLens.wrap self.tintContainer
self.zoomTintcss = self.zoomLens.after(self.zoomTint)
#if tint enabled - set an image to show over the tint
self.zoomTintImage = $('
').appendTo(self.zoomLens).click(->
self.$elem.trigger 'click'
return
)
#create zoom window
if isNaN(self.options.zoomWindowPosition)
self.zoomWindow = $('
').appendTo('body').click(->
self.$elem.trigger 'click'
return
)
else
self.zoomWindow = $('
').appendTo(self.zoomContainer).click(->
self.$elem.trigger 'click'
return
)
self.zoomWindowContainer = $('').addClass('zoomWindowContainer').css('width', self.options.zoomWindowWidth)
self.zoomWindow.wrap self.zoomWindowContainer
# self.captionStyle = "text-align: left;background-color: black;color: white;font-weight: bold;padding: 10px;font-family: sans-serif;font-size: 11px";
# self.zoomCaption = $('INSERT ALT TAG
').appendTo(self.zoomWindow.parent());
if self.options.zoomType == 'lens'
self.zoomLens.css backgroundImage: 'url(\'' + self.imageSrc + '\')'
if self.options.zoomType == 'window'
self.zoomWindow.css backgroundImage: 'url(\'' + self.imageSrc + '\')'
if self.options.zoomType == 'inner'
self.zoomWindow.css backgroundImage: 'url(\'' + self.imageSrc + '\')'
###-------------------END THE ZOOM WINDOW AND LENS----------------------------------###
if self.options.touchEnabled
#touch events
self.$elem.bind 'touchmove', (e) ->
e.preventDefault()
touch = e.originalEvent.touches[0] or e.originalEvent.changedTouches[0]
self.setPosition touch
return
self.zoomContainer.bind 'touchmove', (e) ->
if self.options.zoomType == 'inner'
self.showHideWindow 'show'
e.preventDefault()
touch = e.originalEvent.touches[0] or e.originalEvent.changedTouches[0]
self.setPosition touch
return
self.zoomContainer.bind 'touchend', (e) ->
self.showHideWindow 'hide'
if self.options.showLens
self.showHideLens 'hide'
if self.options.tint and self.options.zoomType != 'inner'
self.showHideTint 'hide'
return
self.$elem.bind 'touchend', (e) ->
self.showHideWindow 'hide'
if self.options.showLens
self.showHideLens 'hide'
if self.options.tint and self.options.zoomType != 'inner'
self.showHideTint 'hide'
return
if self.options.showLens
self.zoomLens.bind 'touchmove', (e) ->
e.preventDefault()
touch = e.originalEvent.touches[0] or e.originalEvent.changedTouches[0]
self.setPosition touch
return
self.zoomLens.bind 'touchend', (e) ->
self.showHideWindow 'hide'
if self.options.showLens
self.showHideLens 'hide'
if self.options.tint and self.options.zoomType != 'inner'
self.showHideTint 'hide'
return
#Needed to work in IE
self.$elem.bind 'mousemove', (e) ->
if self.overWindow == false
self.setElements 'show'
#make sure on orientation change the setposition is not fired
if self.lastX != e.clientX or self.lastY != e.clientY
self.setPosition e
self.currentLoc = e
self.lastX = e.clientX
self.lastY = e.clientY
return
self.zoomContainer.bind 'mousemove', (e) ->
if self.overWindow == false
self.setElements 'show'
#make sure on orientation change the setposition is not fired
if self.lastX != e.clientX or self.lastY != e.clientY
self.setPosition e
self.currentLoc = e
self.lastX = e.clientX
self.lastY = e.clientY
return
if self.options.zoomType != 'inner'
self.zoomLens.bind 'mousemove', (e) ->
#make sure on orientation change the setposition is not fired
if self.lastX != e.clientX or self.lastY != e.clientY
self.setPosition e
self.currentLoc = e
self.lastX = e.clientX
self.lastY = e.clientY
return
if self.options.tint and self.options.zoomType != 'inner'
self.zoomTint.bind 'mousemove', (e) ->
#make sure on orientation change the setposition is not fired
if self.lastX != e.clientX or self.lastY != e.clientY
self.setPosition e
self.currentLoc = e
self.lastX = e.clientX
self.lastY = e.clientY
return
if self.options.zoomType == 'inner'
self.zoomWindow.bind 'mousemove', (e) ->
#self.overWindow = true;
#make sure on orientation change the setposition is not fired
if self.lastX != e.clientX or self.lastY != e.clientY
self.setPosition e
self.currentLoc = e
self.lastX = e.clientX
self.lastY = e.clientY
return
# lensFadeOut: 500, zoomTintFadeIn
self.zoomContainer.add(self.$elem).mouseenter(->
if self.overWindow == false
self.setElements 'show'
return
).mouseleave ->
if !self.scrollLock
self.setElements 'hide'
return
#end ove image
if self.options.zoomType != 'inner'
self.zoomWindow.mouseenter(->
self.overWindow = true
self.setElements 'hide'
return
).mouseleave ->
self.overWindow = false
return
#end ove image
# var delta = parseInt(e.originalEvent.wheelDelta || -e.originalEvent.detail);
# $(this).empty();
# return false;
#fix for initial zoom setting
if self.options.zoomLevel != 1
# self.changeZoomLevel(self.currentZoomLevel);
else
#set the min zoomlevel
if self.options.minZoomLevel
self.minZoomLevel = self.options.minZoomLevel
else
self.minZoomLevel = self.options.scrollZoomIncrement * 2
if self.options.scrollZoom
self.zoomContainer.add(self.$elem).bind 'mousewheel DOMMouseScroll MozMousePixelScroll', (e) ->
# in IE there is issue with firing of mouseleave - So check whether still scrolling
# and on mouseleave check if scrolllock
self.scrollLock = true
clearTimeout $.data(this, 'timer')
$.data this, 'timer', setTimeout((->
self.scrollLock = false
#do something
return
), 250)
theEvent = e.originalEvent.wheelDelta or e.originalEvent.detail * -1
#this.scrollTop += ( delta < 0 ? 1 : -1 ) * 30;
# e.preventDefault();
e.stopImmediatePropagation()
e.stopPropagation()
e.preventDefault()
if theEvent / 120 > 0
#scrolling up
if self.currentZoomLevel >= self.minZoomLevel
self.changeZoomLevel self.currentZoomLevel - (self.options.scrollZoomIncrement)
else
#scrolling down
if self.options.maxZoomLevel
if self.currentZoomLevel <= self.options.maxZoomLevel
self.changeZoomLevel parseFloat(self.currentZoomLevel) + self.options.scrollZoomIncrement
else
#andy
self.changeZoomLevel parseFloat(self.currentZoomLevel) + self.options.scrollZoomIncrement
false
return
setElements: (type) ->
self = this
if !self.options.zoomEnabled
return false
if type == 'show'
if self.isWindowSet
if self.options.zoomType == 'inner'
self.showHideWindow 'show'
if self.options.zoomType == 'window'
self.showHideWindow 'show'
if self.options.showLens
self.showHideLens 'show'
if self.options.tint and self.options.zoomType != 'inner'
self.showHideTint 'show'
if type == 'hide'
if self.options.zoomType == 'window'
self.showHideWindow 'hide'
if !self.options.tint
self.showHideWindow 'hide'
if self.options.showLens
self.showHideLens 'hide'
if self.options.tint
self.showHideTint 'hide'
return
setPosition: (e) ->
self = this
if !self.options.zoomEnabled
return false
#recaclc offset each time in case the image moves
#this can be caused by other on page elements
self.nzHeight = self.$elem.height()
self.nzWidth = self.$elem.width()
self.nzOffset = self.$elem.offset()
if self.options.tint and self.options.zoomType != 'inner'
self.zoomTint.css top: 0
self.zoomTint.css left: 0
#set responsive
#will checking if the image needs changing before running this code work faster?
if self.options.responsive and !self.options.scrollZoom
if self.options.showLens
if self.nzHeight < self.options.zoomWindowWidth / self.widthRatio
lensHeight = self.nzHeight
else
lensHeight = String(self.options.zoomWindowHeight / self.heightRatio)
if self.largeWidth < self.options.zoomWindowWidth
lensWidth = self.nzWidth
else
lensWidth = self.options.zoomWindowWidth / self.widthRatio
self.widthRatio = self.largeWidth / self.nzWidth
self.heightRatio = self.largeHeight / self.nzHeight
if self.options.zoomType != 'lens'
#possibly dont need to keep recalcalculating
#if the lens is heigher than the image, then set lens size to image size
if self.nzHeight < self.options.zoomWindowWidth / self.widthRatio
lensHeight = self.nzHeight
else
lensHeight = String(self.options.zoomWindowHeight / self.heightRatio)
if self.options.zoomWindowWidth < self.options.zoomWindowWidth
lensWidth = self.nzWidth
else
lensWidth = self.options.zoomWindowWidth / self.widthRatio
self.zoomLens.css 'width', lensWidth
self.zoomLens.css 'height', lensHeight
if self.options.tint
self.zoomTintImage.css 'width', self.nzWidth
self.zoomTintImage.css 'height', self.nzHeight
if self.options.zoomType == 'lens'
self.zoomLens.css
width: String(self.options.lensSize) + 'px'
height: String(self.options.lensSize) + 'px'
#end responsive image change
#container fix
self.zoomContainer.css top: self.nzOffset.top
self.zoomContainer.css left: self.nzOffset.left
self.mouseLeft = parseInt(e.pageX - (self.nzOffset.left))
self.mouseTop = parseInt(e.pageY - (self.nzOffset.top))
#calculate the Location of the Lens
#calculate the bound regions - but only if zoom window
if self.options.zoomType == 'window'
self.Etoppos = self.mouseTop < self.zoomLens.height() / 2
self.Eboppos = self.mouseTop > self.nzHeight - (self.zoomLens.height() / 2) - (self.options.lensBorderSize * 2)
self.Eloppos = self.mouseLeft < 0 + self.zoomLens.width() / 2
self.Eroppos = self.mouseLeft > self.nzWidth - (self.zoomLens.width() / 2) - (self.options.lensBorderSize * 2)
#calculate the bound regions - but only for inner zoom
if self.options.zoomType == 'inner'
self.Etoppos = self.mouseTop < self.nzHeight / 2 / self.heightRatio
self.Eboppos = self.mouseTop > self.nzHeight - (self.nzHeight / 2 / self.heightRatio)
self.Eloppos = self.mouseLeft < 0 + self.nzWidth / 2 / self.widthRatio
self.Eroppos = self.mouseLeft > self.nzWidth - (self.nzWidth / 2 / self.widthRatio) - (self.options.lensBorderSize * 2)
# if the mouse position of the slider is one of the outerbounds, then hide window and lens
if self.mouseLeft <= 0 or self.mouseTop < 0 or self.mouseLeft > self.nzWidth or self.mouseTop > self.nzHeight
self.setElements 'hide'
return
else
#lens options
if self.options.showLens
# self.showHideLens("show");
#set background position of lens
self.lensLeftPos = String(self.mouseLeft - (self.zoomLens.width() / 2))
self.lensTopPos = String(self.mouseTop - (self.zoomLens.height() / 2))
#adjust the background position if the mouse is in one of the outer regions
#Top region
if self.Etoppos
self.lensTopPos = 0
#Left Region
if self.Eloppos
self.windowLeftPos = 0
self.lensLeftPos = 0
self.tintpos = 0
#Set bottom and right region for window mode
if self.options.zoomType == 'window'
if self.Eboppos
self.lensTopPos = Math.max(self.nzHeight - self.zoomLens.height() - (self.options.lensBorderSize * 2), 0)
if self.Eroppos
self.lensLeftPos = self.nzWidth - self.zoomLens.width() - (self.options.lensBorderSize * 2)
#Set bottom and right region for inner mode
if self.options.zoomType == 'inner'
if self.Eboppos
self.lensTopPos = Math.max(self.nzHeight - (self.options.lensBorderSize * 2), 0)
if self.Eroppos
self.lensLeftPos = self.nzWidth - (self.nzWidth) - (self.options.lensBorderSize * 2)
#if lens zoom
if self.options.zoomType == 'lens'
self.windowLeftPos = String(((e.pageX - (self.nzOffset.left)) * self.widthRatio - (self.zoomLens.width() / 2)) * -1)
self.windowTopPos = String(((e.pageY - (self.nzOffset.top)) * self.heightRatio - (self.zoomLens.height() / 2)) * -1)
self.zoomLens.css backgroundPosition: self.windowLeftPos + 'px ' + self.windowTopPos + 'px'
if self.changeBgSize
if self.nzHeight > self.nzWidth
if self.options.zoomType == 'lens'
self.zoomLens.css 'background-size': self.largeWidth / self.newvalueheight + 'px ' + self.largeHeight / self.newvalueheight + 'px'
self.zoomWindow.css 'background-size': self.largeWidth / self.newvalueheight + 'px ' + self.largeHeight / self.newvalueheight + 'px'
else
if self.options.zoomType == 'lens'
self.zoomLens.css 'background-size': self.largeWidth / self.newvaluewidth + 'px ' + self.largeHeight / self.newvaluewidth + 'px'
self.zoomWindow.css 'background-size': self.largeWidth / self.newvaluewidth + 'px ' + self.largeHeight / self.newvaluewidth + 'px'
self.changeBgSize = false
self.setWindowPostition e
#if tint zoom
if self.options.tint and self.options.zoomType != 'inner'
self.setTintPosition e
#set the css background position
if self.options.zoomType == 'window'
self.setWindowPostition e
if self.options.zoomType == 'inner'
self.setWindowPostition e
if self.options.showLens
if self.fullwidth and self.options.zoomType != 'lens'
self.lensLeftPos = 0
self.zoomLens.css
left: self.lensLeftPos + 'px'
top: self.lensTopPos + 'px'
#end else
return
showHideWindow: (change) ->
self = this
if change == 'show'
if !self.isWindowActive
if self.options.zoomWindowFadeIn
self.zoomWindow.stop(true, true, false).fadeIn self.options.zoomWindowFadeIn
else
self.zoomWindow.show()
self.isWindowActive = true
if change == 'hide'
if self.isWindowActive
if self.options.zoomWindowFadeOut
self.zoomWindow.stop(true, true).fadeOut self.options.zoomWindowFadeOut
else
self.zoomWindow.hide()
self.isWindowActive = false
return
showHideLens: (change) ->
self = this
if change == 'show'
if !self.isLensActive
if self.options.lensFadeIn
self.zoomLens.stop(true, true, false).fadeIn self.options.lensFadeIn
else
self.zoomLens.show()
self.isLensActive = true
if change == 'hide'
if self.isLensActive
if self.options.lensFadeOut
self.zoomLens.stop(true, true).fadeOut self.options.lensFadeOut
else
self.zoomLens.hide()
self.isLensActive = false
return
showHideTint: (change) ->
self = this
if change == 'show'
if !self.isTintActive
if self.options.zoomTintFadeIn
self.zoomTint.css(opacity: self.options.tintOpacity).animate().stop(true, true).fadeIn 'slow'
else
self.zoomTint.css(opacity: self.options.tintOpacity).animate()
self.zoomTint.show()
self.isTintActive = true
if change == 'hide'
if self.isTintActive
if self.options.zoomTintFadeOut
self.zoomTint.stop(true, true).fadeOut self.options.zoomTintFadeOut
else
self.zoomTint.hide()
self.isTintActive = false
return
setLensPostition: (e) ->
setWindowPostition: (e) ->
#return obj.slice( 0, count );
self = this
if !isNaN(self.options.zoomWindowPosition)
switch self.options.zoomWindowPosition
when 1
#done
self.windowOffsetTop = self.options.zoomWindowOffety
#DONE - 1
self.windowOffsetLeft = +self.nzWidth
#DONE 1, 2, 3, 4, 16
when 2
if self.options.zoomWindowHeight > self.nzHeight
#positive margin
self.windowOffsetTop = (self.options.zoomWindowHeight / 2 - (self.nzHeight / 2)) * -1
self.windowOffsetLeft = self.nzWidth
#DONE 1, 2, 3, 4, 16
else
#negative margin
when 3
#done
self.windowOffsetTop = self.nzHeight - self.zoomWindow.height() - (self.options.borderSize * 2)
#DONE 3,9
self.windowOffsetLeft = self.nzWidth
#DONE 1, 2, 3, 4, 16
when 4
#done
self.windowOffsetTop = self.nzHeight
#DONE - 4,5,6,7,8
self.windowOffsetLeft = self.nzWidth
#DONE 1, 2, 3, 4, 16
when 5
#done
self.windowOffsetTop = self.nzHeight
#DONE - 4,5,6,7,8
self.windowOffsetLeft = self.nzWidth - self.zoomWindow.width() - (self.options.borderSize * 2)
#DONE - 5,15
when 6
if self.options.zoomWindowHeight > self.nzHeight
#positive margin
self.windowOffsetTop = self.nzHeight
#DONE - 4,5,6,7,8
self.windowOffsetLeft = (self.options.zoomWindowWidth / 2 - (self.nzWidth / 2) + self.options.borderSize * 2) * -1
else
#negative margin
when 7
#done
self.windowOffsetTop = self.nzHeight
#DONE - 4,5,6,7,8
self.windowOffsetLeft = 0
#DONE 7, 13
when 8
#done
self.windowOffsetTop = self.nzHeight
#DONE - 4,5,6,7,8
self.windowOffsetLeft = (self.zoomWindow.width() + self.options.borderSize * 2) * -1
#DONE 8,9,10,11,12
when 9
#done
self.windowOffsetTop = self.nzHeight - self.zoomWindow.height() - (self.options.borderSize * 2)
#DONE 3,9
self.windowOffsetLeft = (self.zoomWindow.width() + self.options.borderSize * 2) * -1
#DONE 8,9,10,11,12
when 10
if self.options.zoomWindowHeight > self.nzHeight
#positive margin
self.windowOffsetTop = (self.options.zoomWindowHeight / 2 - (self.nzHeight / 2)) * -1
self.windowOffsetLeft = (self.zoomWindow.width() + self.options.borderSize * 2) * -1
#DONE 8,9,10,11,12
else
#negative margin
when 11
self.windowOffsetTop = self.options.zoomWindowOffety
self.windowOffsetLeft = (self.zoomWindow.width() + self.options.borderSize * 2) * -1
#DONE 8,9,10,11,12
when 12
#done
self.windowOffsetTop = (self.zoomWindow.height() + self.options.borderSize * 2) * -1
#DONE 12,13,14,15,16
self.windowOffsetLeft = (self.zoomWindow.width() + self.options.borderSize * 2) * -1
#DONE 8,9,10,11,12
when 13
#done
self.windowOffsetTop = (self.zoomWindow.height() + self.options.borderSize * 2) * -1
#DONE 12,13,14,15,16
self.windowOffsetLeft = 0
#DONE 7, 13
when 14
if self.options.zoomWindowHeight > self.nzHeight
#positive margin
self.windowOffsetTop = (self.zoomWindow.height() + self.options.borderSize * 2) * -1
#DONE 12,13,14,15,16
self.windowOffsetLeft = (self.options.zoomWindowWidth / 2 - (self.nzWidth / 2) + self.options.borderSize * 2) * -1
else
#negative margin
when 15
#done
self.windowOffsetTop = (self.zoomWindow.height() + self.options.borderSize * 2) * -1
#DONE 12,13,14,15,16
self.windowOffsetLeft = self.nzWidth - self.zoomWindow.width() - (self.options.borderSize * 2)
#DONE - 5,15
when 16
#done
self.windowOffsetTop = (self.zoomWindow.height() + self.options.borderSize * 2) * -1
#DONE 12,13,14,15,16
self.windowOffsetLeft = self.nzWidth
#DONE 1, 2, 3, 4, 16
else
#done
self.windowOffsetTop = self.options.zoomWindowOffety
#DONE - 1
self.windowOffsetLeft = self.nzWidth
#DONE 1, 2, 3, 4, 16
else
#WE CAN POSITION IN A CLASS - ASSUME THAT ANY STRING PASSED IS
self.externalContainer = $('#' + self.options.zoomWindowPosition)
self.externalContainerWidth = self.externalContainer.width()
self.externalContainerHeight = self.externalContainer.height()
self.externalContainerOffset = self.externalContainer.offset()
self.windowOffsetTop = self.externalContainerOffset.top
#DONE - 1
self.windowOffsetLeft = self.externalContainerOffset.left
#DONE 1, 2, 3, 4, 16
self.isWindowSet = true
self.windowOffsetTop = self.windowOffsetTop + self.options.zoomWindowOffety
self.windowOffsetLeft = self.windowOffsetLeft + self.options.zoomWindowOffetx
self.zoomWindow.css top: self.windowOffsetTop
self.zoomWindow.css left: self.windowOffsetLeft
if self.options.zoomType == 'inner'
self.zoomWindow.css top: 0
self.zoomWindow.css left: 0
self.windowLeftPos = String(((e.pageX - (self.nzOffset.left)) * self.widthRatio - (self.zoomWindow.width() / 2)) * -1)
self.windowTopPos = String(((e.pageY - (self.nzOffset.top)) * self.heightRatio - (self.zoomWindow.height() / 2)) * -1)
if self.Etoppos
self.windowTopPos = 0
if self.Eloppos
self.windowLeftPos = 0
if self.Eboppos
self.windowTopPos = (self.largeHeight / self.currentZoomLevel - self.zoomWindow.height()) * -1
if self.Eroppos
self.windowLeftPos = (self.largeWidth / self.currentZoomLevel - self.zoomWindow.width()) * -1
#stops micro movements
if self.fullheight
self.windowTopPos = 0
if self.fullwidth
self.windowLeftPos = 0
#set the css background position
if self.options.zoomType == 'window' or self.options.zoomType == 'inner'
if self.zoomLock == 1
#overrides for images not zoomable
if self.widthRatio <= 1
self.windowLeftPos = 0
if self.heightRatio <= 1
self.windowTopPos = 0
# adjust images less than the window height
if self.largeHeight < self.options.zoomWindowHeight
self.windowTopPos = 0
if self.largeWidth < self.options.zoomWindowWidth
self.windowLeftPos = 0
#set the zoomwindow background position
if self.options.easing
# if(self.changeZoom){
# clearInterval(self.loop);
# self.changeZoom = false;
# self.loop = false;
# }
#set the pos to 0 if not set
if !self.xp
self.xp = 0
if !self.yp
self.yp = 0
#if loop not already started, then run it
if !self.loop
self.loop = setInterval((->
#using zeno's paradox
self.xp += (self.windowLeftPos - (self.xp)) / self.options.easingAmount
self.yp += (self.windowTopPos - (self.yp)) / self.options.easingAmount
if self.scrollingLock
clearInterval self.loop
self.xp = self.windowLeftPos
self.yp = self.windowTopPos
self.xp = ((e.pageX - (self.nzOffset.left)) * self.widthRatio - (self.zoomWindow.width() / 2)) * -1
self.yp = ((e.pageY - (self.nzOffset.top)) * self.heightRatio - (self.zoomWindow.height() / 2)) * -1
if self.changeBgSize
if self.nzHeight > self.nzWidth
if self.options.zoomType == 'lens'
self.zoomLens.css 'background-size': self.largeWidth / self.newvalueheight + 'px ' + self.largeHeight / self.newvalueheight + 'px'
self.zoomWindow.css 'background-size': self.largeWidth / self.newvalueheight + 'px ' + self.largeHeight / self.newvalueheight + 'px'
else
if self.options.zoomType != 'lens'
self.zoomLens.css 'background-size': self.largeWidth / self.newvaluewidth + 'px ' + self.largeHeight / self.newvalueheight + 'px'
self.zoomWindow.css 'background-size': self.largeWidth / self.newvaluewidth + 'px ' + self.largeHeight / self.newvaluewidth + 'px'
###
if(!self.bgxp){self.bgxp = self.largeWidth/self.newvalue;}
if(!self.bgyp){self.bgyp = self.largeHeight/self.newvalue ;}
if (!self.bgloop){
self.bgloop = setInterval(function(){
self.bgxp += (self.largeWidth/self.newvalue - self.bgxp) / self.options.easingAmount;
self.bgyp += (self.largeHeight/self.newvalue - self.bgyp) / self.options.easingAmount;
self.zoomWindow.css({ "background-size": self.bgxp + 'px ' + self.bgyp + 'px' });
}, 16);
}
###
self.changeBgSize = false
self.zoomWindow.css backgroundPosition: self.windowLeftPos + 'px ' + self.windowTopPos + 'px'
self.scrollingLock = false
self.loop = false
else
if self.changeBgSize
if self.nzHeight > self.nzWidth
if self.options.zoomType == 'lens'
self.zoomLens.css 'background-size': self.largeWidth / self.newvalueheight + 'px ' + self.largeHeight / self.newvalueheight + 'px'
self.zoomWindow.css 'background-size': self.largeWidth / self.newvalueheight + 'px ' + self.largeHeight / self.newvalueheight + 'px'
else
if self.options.zoomType != 'lens'
self.zoomLens.css 'background-size': self.largeWidth / self.newvaluewidth + 'px ' + self.largeHeight / self.newvaluewidth + 'px'
self.zoomWindow.css 'background-size': self.largeWidth / self.newvaluewidth + 'px ' + self.largeHeight / self.newvaluewidth + 'px'
self.changeBgSize = false
self.zoomWindow.css backgroundPosition: self.xp + 'px ' + self.yp + 'px'
return
), 16)
else
if self.changeBgSize
if self.nzHeight > self.nzWidth
if self.options.zoomType == 'lens'
self.zoomLens.css 'background-size': self.largeWidth / self.newvalueheight + 'px ' + self.largeHeight / self.newvalueheight + 'px'
self.zoomWindow.css 'background-size': self.largeWidth / self.newvalueheight + 'px ' + self.largeHeight / self.newvalueheight + 'px'
else
if self.options.zoomType == 'lens'
self.zoomLens.css 'background-size': self.largeWidth / self.newvaluewidth + 'px ' + self.largeHeight / self.newvaluewidth + 'px'
if self.largeHeight / self.newvaluewidth < self.options.zoomWindowHeight
self.zoomWindow.css 'background-size': self.largeWidth / self.newvaluewidth + 'px ' + self.largeHeight / self.newvaluewidth + 'px'
else
self.zoomWindow.css 'background-size': self.largeWidth / self.newvalueheight + 'px ' + self.largeHeight / self.newvalueheight + 'px'
self.changeBgSize = false
self.zoomWindow.css backgroundPosition: self.windowLeftPos + 'px ' + self.windowTopPos + 'px'
return
setTintPosition: (e) ->
self = this
self.nzOffset = self.$elem.offset()
self.tintpos = String((e.pageX - (self.nzOffset.left) - (self.zoomLens.width() / 2)) * -1)
self.tintposy = String((e.pageY - (self.nzOffset.top) - (self.zoomLens.height() / 2)) * -1)
if self.Etoppos
self.tintposy = 0
if self.Eloppos
self.tintpos = 0
if self.Eboppos
self.tintposy = (self.nzHeight - self.zoomLens.height() - (self.options.lensBorderSize * 2)) * -1
if self.Eroppos
self.tintpos = (self.nzWidth - self.zoomLens.width() - (self.options.lensBorderSize * 2)) * -1
if self.options.tint
#stops micro movements
if self.fullheight
self.tintposy = 0
if self.fullwidth
self.tintpos = 0
self.zoomTintImage.css 'left': self.tintpos + 'px'
self.zoomTintImage.css 'top': self.tintposy + 'px'
return
swaptheimage: (smallimage, largeimage) ->
self = this
newImg = new Image
if self.options.loadingIcon
self.spinner = $('')
self.$elem.after self.spinner
self.options.onImageSwap self.$elem
newImg.onload = ->
self.largeWidth = newImg.width
self.largeHeight = newImg.height
self.zoomImage = largeimage
self.zoomWindow.css 'background-size': self.largeWidth + 'px ' + self.largeHeight + 'px'
self.zoomWindow.css 'background-size': self.largeWidth + 'px ' + self.largeHeight + 'px'
self.swapAction smallimage, largeimage
return
newImg.src = largeimage
# this must be done AFTER setting onload
return
swapAction: (smallimage, largeimage) ->
self = this
newImg2 = new Image
newImg2.onload = ->
#re-calculate values
self.nzHeight = newImg2.height
self.nzWidth = newImg2.width
self.options.onImageSwapComplete self.$elem
self.doneCallback()
return
newImg2.src = smallimage
#reset the zoomlevel to that initially set in options
self.currentZoomLevel = self.options.zoomLevel
self.options.maxZoomLevel = false
#swaps the main image
#self.$elem.attr("src",smallimage);
#swaps the zoom image
if self.options.zoomType == 'lens'
self.zoomLens.css backgroundImage: 'url(\'' + largeimage + '\')'
if self.options.zoomType == 'window'
self.zoomWindow.css backgroundImage: 'url(\'' + largeimage + '\')'
if self.options.zoomType == 'inner'
self.zoomWindow.css backgroundImage: 'url(\'' + largeimage + '\')'
self.currentImage = largeimage
if self.options.imageCrossfade
oldImg = self.$elem
newImg = oldImg.clone()
self.$elem.attr 'src', smallimage
self.$elem.after newImg
newImg.stop(true).fadeOut self.options.imageCrossfade, ->
$(this).remove()
return
# if(self.options.zoomType == "inner"){
#remove any attributes on the cloned image so we can resize later
self.$elem.width('auto').removeAttr 'width'
self.$elem.height('auto').removeAttr 'height'
# }
oldImg.fadeIn self.options.imageCrossfade
if self.options.tint and self.options.zoomType != 'inner'
oldImgTint = self.zoomTintImage
newImgTint = oldImgTint.clone()
self.zoomTintImage.attr 'src', largeimage
self.zoomTintImage.after newImgTint
newImgTint.stop(true).fadeOut self.options.imageCrossfade, ->
$(this).remove()
return
oldImgTint.fadeIn self.options.imageCrossfade
#self.zoomTintImage.attr("width",elem.data("image"));
#resize the tint window
self.zoomTint.css height: self.$elem.height()
self.zoomTint.css width: self.$elem.width()
self.zoomContainer.css 'height', self.$elem.height()
self.zoomContainer.css 'width', self.$elem.width()
if self.options.zoomType == 'inner'
if !self.options.constrainType
self.zoomWrap.parent().css 'height', self.$elem.height()
self.zoomWrap.parent().css 'width', self.$elem.width()
self.zoomWindow.css 'height', self.$elem.height()
self.zoomWindow.css 'width', self.$elem.width()
if self.options.imageCrossfade
self.zoomWrap.css 'height', self.$elem.height()
self.zoomWrap.css 'width', self.$elem.width()
else
self.$elem.attr 'src', smallimage
if self.options.tint
self.zoomTintImage.attr 'src', largeimage
#self.zoomTintImage.attr("width",elem.data("image"));
self.zoomTintImage.attr 'height', self.$elem.height()
#self.zoomTintImage.attr('src') = elem.data("image");
self.zoomTintImage.css height: self.$elem.height()
self.zoomTint.css height: self.$elem.height()
self.zoomContainer.css 'height', self.$elem.height()
self.zoomContainer.css 'width', self.$elem.width()
if self.options.imageCrossfade
self.zoomWrap.css 'height', self.$elem.height()
self.zoomWrap.css 'width', self.$elem.width()
if self.options.constrainType
#This will contrain the image proportions
if self.options.constrainType == 'height'
self.zoomContainer.css 'height', self.options.constrainSize
self.zoomContainer.css 'width', 'auto'
if self.options.imageCrossfade
self.zoomWrap.css 'height', self.options.constrainSize
self.zoomWrap.css 'width', 'auto'
self.constwidth = self.zoomWrap.width()
else
self.$elem.css 'height', self.options.constrainSize
self.$elem.css 'width', 'auto'
self.constwidth = self.$elem.width()
if self.options.zoomType == 'inner'
self.zoomWrap.parent().css 'height', self.options.constrainSize
self.zoomWrap.parent().css 'width', self.constwidth
self.zoomWindow.css 'height', self.options.constrainSize
self.zoomWindow.css 'width', self.constwidth
if self.options.tint
self.tintContainer.css 'height', self.options.constrainSize
self.tintContainer.css 'width', self.constwidth
self.zoomTint.css 'height', self.options.constrainSize
self.zoomTint.css 'width', self.constwidth
self.zoomTintImage.css 'height', self.options.constrainSize
self.zoomTintImage.css 'width', self.constwidth
if self.options.constrainType == 'width'
self.zoomContainer.css 'height', 'auto'
self.zoomContainer.css 'width', self.options.constrainSize
if self.options.imageCrossfade
self.zoomWrap.css 'height', 'auto'
self.zoomWrap.css 'width', self.options.constrainSize
self.constheight = self.zoomWrap.height()
else
self.$elem.css 'height', 'auto'
self.$elem.css 'width', self.options.constrainSize
self.constheight = self.$elem.height()
if self.options.zoomType == 'inner'
self.zoomWrap.parent().css 'height', self.constheight
self.zoomWrap.parent().css 'width', self.options.constrainSize
self.zoomWindow.css 'height', self.constheight
self.zoomWindow.css 'width', self.options.constrainSize
if self.options.tint
self.tintContainer.css 'height', self.constheight
self.tintContainer.css 'width', self.options.constrainSize
self.zoomTint.css 'height', self.constheight
self.zoomTint.css 'width', self.options.constrainSize
self.zoomTintImage.css 'height', self.constheight
self.zoomTintImage.css 'width', self.options.constrainSize
return
doneCallback: ->
self = this
if self.options.loadingIcon
self.spinner.hide()
self.nzOffset = self.$elem.offset()
self.nzWidth = self.$elem.width()
self.nzHeight = self.$elem.height()
# reset the zoomlevel back to default
self.currentZoomLevel = self.options.zoomLevel
#ratio of the large to small image
self.widthRatio = self.largeWidth / self.nzWidth
self.heightRatio = self.largeHeight / self.nzHeight
#NEED TO ADD THE LENS SIZE FOR ROUND
# adjust images less than the window height
if self.options.zoomType == 'window'
if self.nzHeight < self.options.zoomWindowWidth / self.widthRatio
lensHeight = self.nzHeight
else
lensHeight = String(self.options.zoomWindowHeight / self.heightRatio)
if self.options.zoomWindowWidth < self.options.zoomWindowWidth
lensWidth = self.nzWidth
else
lensWidth = self.options.zoomWindowWidth / self.widthRatio
if self.zoomLens
self.zoomLens.css 'width', lensWidth
self.zoomLens.css 'height', lensHeight
return
getCurrentImage: ->
self = this
self.zoomImage
getGalleryList: ->
self = this
#loop through the gallery options and set them in list for fancybox
self.gallerylist = []
if self.options.gallery
$('#' + self.options.gallery + ' a').each ->
img_src = ''
if $(this).data('zoom-image')
img_src = $(this).data('zoom-image')
else if $(this).data('image')
img_src = $(this).data('image')
#put the current image at the start
if img_src == self.zoomImage
self.gallerylist.unshift
href: '' + img_src + ''
title: $(this).find('img').attr('title')
else
self.gallerylist.push
href: '' + img_src + ''
title: $(this).find('img').attr('title')
return
else
self.gallerylist.push
href: '' + self.zoomImage + ''
title: $(this).find('img').attr('title')
self.gallerylist
changeZoomLevel: (value) ->
self = this
#flag a zoom, so can adjust the easing during setPosition
self.scrollingLock = true
#round to two decimal places
self.newvalue = parseFloat(value).toFixed(2)
newvalue = parseFloat(value).toFixed(2)
#maxwidth & Maxheight of the image
maxheightnewvalue = self.largeHeight / (self.options.zoomWindowHeight / self.nzHeight * self.nzHeight)
maxwidthtnewvalue = self.largeWidth / (self.options.zoomWindowWidth / self.nzWidth * self.nzWidth)
#calculate new heightratio
if self.options.zoomType != 'inner'
if maxheightnewvalue <= newvalue
self.heightRatio = self.largeHeight / maxheightnewvalue / self.nzHeight
self.newvalueheight = maxheightnewvalue
self.fullheight = true
else
self.heightRatio = self.largeHeight / newvalue / self.nzHeight
self.newvalueheight = newvalue
self.fullheight = false
# calculate new width ratio
if maxwidthtnewvalue <= newvalue
self.widthRatio = self.largeWidth / maxwidthtnewvalue / self.nzWidth
self.newvaluewidth = maxwidthtnewvalue
self.fullwidth = true
else
self.widthRatio = self.largeWidth / newvalue / self.nzWidth
self.newvaluewidth = newvalue
self.fullwidth = false
if self.options.zoomType == 'lens'
if maxheightnewvalue <= newvalue
self.fullwidth = true
self.newvaluewidth = maxheightnewvalue
else
self.widthRatio = self.largeWidth / newvalue / self.nzWidth
self.newvaluewidth = newvalue
self.fullwidth = false
if self.options.zoomType == 'inner'
maxheightnewvalue = parseFloat(self.largeHeight / self.nzHeight).toFixed(2)
maxwidthtnewvalue = parseFloat(self.largeWidth / self.nzWidth).toFixed(2)
if newvalue > maxheightnewvalue
newvalue = maxheightnewvalue
if newvalue > maxwidthtnewvalue
newvalue = maxwidthtnewvalue
if maxheightnewvalue <= newvalue
self.heightRatio = self.largeHeight / newvalue / self.nzHeight
if newvalue > maxheightnewvalue
self.newvalueheight = maxheightnewvalue
else
self.newvalueheight = newvalue
self.fullheight = true
else
self.heightRatio = self.largeHeight / newvalue / self.nzHeight
if newvalue > maxheightnewvalue
self.newvalueheight = maxheightnewvalue
else
self.newvalueheight = newvalue
self.fullheight = false
if maxwidthtnewvalue <= newvalue
self.widthRatio = self.largeWidth / newvalue / self.nzWidth
if newvalue > maxwidthtnewvalue
self.newvaluewidth = maxwidthtnewvalue
else
self.newvaluewidth = newvalue
self.fullwidth = true
else
self.widthRatio = self.largeWidth / newvalue / self.nzWidth
self.newvaluewidth = newvalue
self.fullwidth = false
#end inner
scrcontinue = false
if self.options.zoomType == 'inner'
if self.nzWidth >= self.nzHeight
if self.newvaluewidth <= maxwidthtnewvalue
scrcontinue = true
else
scrcontinue = false
self.fullheight = true
self.fullwidth = true
if self.nzHeight > self.nzWidth
if self.newvaluewidth <= maxwidthtnewvalue
scrcontinue = true
else
scrcontinue = false
self.fullheight = true
self.fullwidth = true
if self.options.zoomType != 'inner'
scrcontinue = true
if scrcontinue
self.zoomLock = 0
self.changeZoom = true
#if lens height is less than image height
if self.options.zoomWindowHeight / self.heightRatio <= self.nzHeight
self.currentZoomLevel = self.newvalueheight
if self.options.zoomType != 'lens' and self.options.zoomType != 'inner'
self.changeBgSize = true
self.zoomLens.css height: String(self.options.zoomWindowHeight / self.heightRatio) + 'px'
if self.options.zoomType == 'lens' or self.options.zoomType == 'inner'
self.changeBgSize = true
if self.options.zoomWindowWidth / self.widthRatio <= self.nzWidth
if self.options.zoomType != 'inner'
if self.newvaluewidth > self.newvalueheight
self.currentZoomLevel = self.newvaluewidth
if self.options.zoomType != 'lens' and self.options.zoomType != 'inner'
self.changeBgSize = true
self.zoomLens.css width: String(self.options.zoomWindowWidth / self.widthRatio) + 'px'
if self.options.zoomType == 'lens' or self.options.zoomType == 'inner'
self.changeBgSize = true
if self.options.zoomType == 'inner'
self.changeBgSize = true
if self.nzWidth > self.nzHeight
self.currentZoomLevel = self.newvaluewidth
if self.nzHeight > self.nzWidth
self.currentZoomLevel = self.newvaluewidth
#under
#sets the boundry change, called in setWindowPos
self.setPosition self.currentLoc
#
return
closeAll: ->
if self.zoomWindow
self.zoomWindow.hide()
if self.zoomLens
self.zoomLens.hide()
if self.zoomTint
self.zoomTint.hide()
return
changeState: (value) ->
self = this
if value == 'enable'
self.options.zoomEnabled = true
if value == 'disable'
self.options.zoomEnabled = false
return
responsiveConfig: (options) ->
if options.respond and options.respond.length > 0
return $.extend({}, options, @configByScreenWidth(options))
options
configByScreenWidth: (options) ->
screenWidth = $(window).width()
config = $.grep(options.respond, (item) ->
range = item.range.split('-')
screenWidth >= range[0] and screenWidth <= range[1]
)
if config.length > 0
config[0]
else
options
$.fn.ezPlus = (options) ->
@each ->
elevate = Object.create(EZP)
elevate.init options, this
$.data this, 'ezPlus', elevate
return
$.fn.ezPlus.options =
borderColour: '#888'
borderSize: 4
constrainSize: false
constrainType: false
containLensZoom: false
cursor: 'default'
debug: false
easing: false
easingAmount: 12
enabled: true
gallery: false
galleryActiveClass: 'zoomGalleryActive'
imageCrossfade: false
lensBorderColour: '#000'
lensBorderSize: 1
lensColour: 'white'
lensFadeIn: false
lensFadeOut: false
lensOpacity: 0.4
lensShape: 'square'
lensSize: 200
lenszoom: false
loadingIcon: false
maxZoomLevel: false
minZoomLevel: false
onComplete: $.noop
onImageSwap: $.noop
onImageSwapComplete: $.noop
onZoomedImageLoaded: ->
preloading: 1
respond: []
responsive: true
scrollZoom: false
scrollZoomIncrement: 0.1
showLens: true
tint: false
tintColour: '#333'
tintOpacity: 0.4
touchEnabled: true
zoomActivation: 'hover'
zoomLevel: 1
zoomTintFadeIn: false
zoomTintFadeOut: false
zoomType: 'window'
zoomWindowAlwaysShow: false
zoomWindowBgColour: '#fff'
zoomWindowFadeIn: false
zoomWindowFadeOut: false
zoomWindowHeight: 400
zoomWindowOffetx: 0
zoomWindowOffety: 0
zoomWindowPosition: 1
zoomWindowWidth: 400
zoomEnabled: true
return
) jQuery, window, document