Project-Pro/redline.com.pl
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
8e99578ae92d0e7799674ca1e99301d187215de1
redline.com.pl/themes/at_movic/assets/js/custom.js

4325 lines
106 KiB
JavaScript
Raw Blame History

/*
* @Website: apollotheme.com - prestashop template provider
* @author Apollotheme <apollotheme@gmail.com>
* @copyright Apollotheme
* @description: ApPageBuilder is module help you can build content for your shop
*/
/*
* Custom code goes here.
* A template should always ship with an empty custom.js
*/
function initSlider(selector, options) {
if ($.fn.slick) {
$(selector).slick(options)
} else {
;(function (factory) {
'use strict'
if (typeof define === 'function' && define.amd) {
define(['jquery'], factory)
} else if (typeof exports !== 'undefined') {
module.exports = factory(require('jquery'))
} else {
factory(jQuery)
}
})(function ($) {
'use strict'
var Slick = window.Slick || {}
Slick = (function () {
var instanceUid = 0
function Slick(element, settings) {
var _ = this,
dataSettings
_.defaults = {
accessibility: true,
adaptiveHeight: false,
appendArrows: $(element),
appendDots: $(element),
arrows: true,
asNavFor: null,
prevArrow:
'<button class="slick-prev" aria-label="Previous" type="button">Previous</button>',
nextArrow:
'<button class="slick-next" aria-label="Next" type="button">Next</button>',
autoplay: false,
autoplaySpeed: 3000,
centerMode: false,
centerPadding: '50px',
cssEase: 'ease',
customPaging: function (slider, i) {
return $('<button type="button" />').text(i + 1)
},
dots: false,
dotsClass: 'slick-dots',
draggable: true,
easing: 'linear',
edgeFriction: 0.35,
fade: false,
focusOnSelect: false,
focusOnChange: false,
infinite: true,
initialSlide: 0,
lazyLoad: 'ondemand',
mobileFirst: false,
pauseOnHover: true,
pauseOnFocus: true,
pauseOnDotsHover: false,
respondTo: 'window',
responsive: null,
rows: 1,
rtl: false,
slide: '',
slidesPerRow: 1,
slidesToShow: 1,
slidesToScroll: 1,
speed: 500,
swipe: true,
swipeToSlide: false,
touchMove: true,
touchThreshold: 5,
useCSS: true,
useTransform: true,
variableWidth: false,
vertical: false,
verticalSwiping: false,
waitForAnimate: true,
zIndex: 1000,
}
_.initials = {
animating: false,
dragging: false,
autoPlayTimer: null,
currentDirection: 0,
currentLeft: null,
currentSlide: 0,
direction: 1,
$dots: null,
listWidth: null,
listHeight: null,
loadIndex: 0,
$nextArrow: null,
$prevArrow: null,
scrolling: false,
slideCount: null,
slideWidth: null,
$slideTrack: null,
$slides: null,
sliding: false,
slideOffset: 0,
swipeLeft: null,
swiping: false,
$list: null,
touchObject: {},
transformsEnabled: false,
unslicked: false,
}
$.extend(_, _.initials)
_.activeBreakpoint = null
_.animType = null
_.animProp = null
_.breakpoints = []
_.breakpointSettings = []
_.cssTransitions = false
_.focussed = false
_.interrupted = false
_.hidden = 'hidden'
_.paused = true
_.positionProp = null
_.respondTo = null
_.rowCount = 1
_.shouldClick = true
_.$slider = $(element)
_.$slidesCache = null
_.transformType = null
_.transitionType = null
_.visibilityChange = 'visibilitychange'
_.windowWidth = 0
_.windowTimer = null
dataSettings = $(element).data('slick') || {}
_.options = $.extend({}, _.defaults, settings, dataSettings)
_.currentSlide = _.options.initialSlide
_.originalSettings = _.options
if (typeof document.mozHidden !== 'undefined') {
_.hidden = 'mozHidden'
_.visibilityChange = 'mozvisibilitychange'
} else if (typeof document.webkitHidden !== 'undefined') {
_.hidden = 'webkitHidden'
_.visibilityChange = 'webkitvisibilitychange'
}
_.autoPlay = $.proxy(_.autoPlay, _)
_.autoPlayClear = $.proxy(_.autoPlayClear, _)
_.autoPlayIterator = $.proxy(_.autoPlayIterator, _)
_.changeSlide = $.proxy(_.changeSlide, _)
_.clickHandler = $.proxy(_.clickHandler, _)
_.selectHandler = $.proxy(_.selectHandler, _)
_.setPosition = $.proxy(_.setPosition, _)
_.swipeHandler = $.proxy(_.swipeHandler, _)
_.dragHandler = $.proxy(_.dragHandler, _)
_.keyHandler = $.proxy(_.keyHandler, _)
_.instanceUid = instanceUid++
// A simple way to check for HTML strings
// Strict HTML recognition (must start with <)
// Extracted from jQuery v1.11 source
_.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/
_.registerBreakpoints()
_.init(true)
}
return Slick
})()
Slick.prototype.activateADA = function () {
var _ = this
if (_.$slideTrack) {
_.$slideTrack
.find('.slick-active')
.attr({
'aria-hidden': 'false',
})
.find('a, input, button, select')
.attr({
tabindex: '0',
})
}
}
Slick.prototype.addSlide = Slick.prototype.slickAdd = function (
markup,
index,
addBefore
) {
var _ = this
if (typeof index === 'boolean') {
addBefore = index
index = null
} else if (index < 0 || index >= _.slideCount) {
return false
}
_.unload()
if (typeof index === 'number') {
if (index === 0 && _.$slides.length === 0) {
$(markup).appendTo(_.$slideTrack)
} else if (addBefore) {
$(markup).insertBefore(_.$slides.eq(index))
} else {
$(markup).insertAfter(_.$slides.eq(index))
}
} else {
if (addBefore === true) {
$(markup).prependTo(_.$slideTrack)
} else {
$(markup).appendTo(_.$slideTrack)
}
}
_.$slides = _.$slideTrack.children(this.options.slide)
_.$slideTrack.children(this.options.slide).detach()
_.$slideTrack.append(_.$slides)
_.$slides.each(function (index, element) {
$(element).attr('data-slick-index', index)
})
_.$slidesCache = _.$slides
_.reinit()
}
Slick.prototype.animateHeight = function () {
var _ = this
if (
_.options.slidesToShow === 1 &&
_.options.adaptiveHeight === true &&
_.options.vertical === false
) {
var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true)
_.$list.animate(
{
height: targetHeight,
},
_.options.speed
)
}
}
Slick.prototype.animateSlide = function (targetLeft, callback) {
var animProps = {},
_ = this
_.animateHeight()
if (_.options.rtl === true && _.options.vertical === false) {
targetLeft = -targetLeft
}
if (_.transformsEnabled === false) {
if (_.options.vertical === false) {
_.$slideTrack.animate(
{
left: targetLeft,
},
_.options.speed,
_.options.easing,
callback
)
} else {
_.$slideTrack.animate(
{
top: targetLeft,
},
_.options.speed,
_.options.easing,
callback
)
}
} else {
if (_.cssTransitions === false) {
if (_.options.rtl === true) {
_.currentLeft = -_.currentLeft
}
$({
animStart: _.currentLeft,
}).animate(
{
animStart: targetLeft,
},
{
duration: _.options.speed,
easing: _.options.easing,
step: function (now) {
now = Math.ceil(now)
if (_.options.vertical === false) {
animProps[_.animType] = 'translate(' + now + 'px, 0px)'
_.$slideTrack.css(animProps)
} else {
animProps[_.animType] = 'translate(0px,' + now + 'px)'
_.$slideTrack.css(animProps)
}
},
complete: function () {
if (callback) {
callback.call()
}
},
}
)
} else {
_.applyTransition()
targetLeft = Math.ceil(targetLeft)
if (_.options.vertical === false) {
animProps[_.animType] =
'translate3d(' + targetLeft + 'px, 0px, 0px)'
} else {
animProps[_.animType] =
'translate3d(0px,' + targetLeft + 'px, 0px)'
}
_.$slideTrack.css(animProps)
if (callback) {
setTimeout(function () {
_.disableTransition()
callback.call()
}, _.options.speed)
}
}
}
}
Slick.prototype.getNavTarget = function () {
var _ = this,
asNavFor = _.options.asNavFor
if (asNavFor && asNavFor !== null) {
asNavFor = $(asNavFor).not(_.$slider)
}
return asNavFor
}
Slick.prototype.asNavFor = function (index) {
var _ = this,
asNavFor = _.getNavTarget()
if (asNavFor !== null && typeof asNavFor === 'object') {
asNavFor.each(function () {
var target = $(this).slick('getSlick')
if (!target.unslicked) {
target.slideHandler(index, true)
}
})
}
}
Slick.prototype.applyTransition = function (slide) {
var _ = this,
transition = {}
if (_.options.fade === false) {
transition[_.transitionType] =
_.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase
} else {
transition[_.transitionType] =
'opacity ' + _.options.speed + 'ms ' + _.options.cssEase
}
if (_.options.fade === false) {
_.$slideTrack.css(transition)
} else {
_.$slides.eq(slide).css(transition)
}
}
Slick.prototype.autoPlay = function () {
var _ = this
_.autoPlayClear()
if (_.slideCount > _.options.slidesToShow) {
_.autoPlayTimer = setInterval(
_.autoPlayIterator,
_.options.autoplaySpeed
)
}
}
Slick.prototype.autoPlayClear = function () {
var _ = this
if (_.autoPlayTimer) {
clearInterval(_.autoPlayTimer)
}
}
Slick.prototype.autoPlayIterator = function () {
var _ = this,
slideTo = _.currentSlide + _.options.slidesToScroll
if (!_.paused && !_.interrupted && !_.focussed) {
if (_.options.infinite === false) {
if (_.direction === 1 && _.currentSlide + 1 === _.slideCount - 1) {
_.direction = 0
} else if (_.direction === 0) {
slideTo = _.currentSlide - _.options.slidesToScroll
if (_.currentSlide - 1 === 0) {
_.direction = 1
}
}
}
_.slideHandler(slideTo)
}
}
Slick.prototype.buildArrows = function () {
var _ = this
if (_.options.arrows === true) {
_.$prevArrow = $(_.options.prevArrow).addClass('slick-arrow')
_.$nextArrow = $(_.options.nextArrow).addClass('slick-arrow')
//THANHNT: add class has-arrow when pagination
if (!_.$slider.hasClass('has-arrows'))
_.$slider.addClass('has-arrows')
if (_.slideCount > _.options.slidesToShow) {
_.$prevArrow
.removeClass('slick-hidden')
.removeAttr('aria-hidden tabindex')
_.$nextArrow
.removeClass('slick-hidden')
.removeAttr('aria-hidden tabindex')
if (
_.htmlExpr.test(_.options.nextArrow) &&
_.htmlExpr.test(_.options.prevArrow)
) {
_.options.appendArrows.find('.slick-arrows').remove()
_.options.appendArrows.append('<div class="slick-arrows "></div>')
_.options.appendArrows.find('.slick-arrows').prepend(_.$prevArrow)
_.options.appendArrows.find('.slick-arrows').append(_.$nextArrow)
}
if (_.options.infinite !== true) {
_.$prevArrow
.addClass('slick-disabled')
.attr('aria-disabled', 'true')
}
} else {
//THANHNT: remove class has-arrow when no pagination
if (_.$slider.hasClass('has-arrows'))
_.$slider.removeClass('has-arrows')
_.$prevArrow
.add(_.$nextArrow)
.addClass('slick-hidden')
.attr({
'aria-disabled': 'true',
tabindex: '-1',
})
}
}
}
Slick.prototype.buildDots = function () {
var _ = this,
i,
dot
if (_.options.dots === true) {
_.$slider.addClass('slick-dotted')
dot = $('<ul />').addClass(_.options.dotsClass)
for (i = 0; i <= _.getDotCount(); i += 1) {
dot.append(
$('<li />').append(_.options.customPaging.call(this, _, i))
)
}
_.$dots = dot.appendTo(_.options.appendDots)
_.$dots.find('li').first().addClass('slick-active')
}
}
Slick.prototype.buildOut = function () {
var _ = this
_.$slides = _.$slider
.children(_.options.slide + ':not(.slick-cloned, .slick-arrows)')
.addClass('slick-slide')
_.slideCount = _.$slides.length
_.$slides.each(function (index, element) {
$(element)
.attr('data-slick-index', index)
.data('originalStyling', $(element).attr('style') || '')
})
_.$slider.addClass('slick-slider')
_.$slideTrack =
_.slideCount === 0
? $('<div class="slick-track"/>').appendTo(_.$slider)
: _.$slides.wrapAll('<div class="slick-track"/>').parent()
_.$list = _.$slideTrack.wrap('<div class="slick-list"/>').parent()
_.$slideTrack.css('opacity', 0)
if (_.options.centerMode === true || _.options.swipeToSlide === true) {
_.options.slidesToScroll = 1
}
$('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading')
_.setupInfinite()
_.buildArrows()
_.buildDots()
_.updateDots()
_.setSlideClasses(
typeof _.currentSlide === 'number' ? _.currentSlide : 0
)
if (_.options.draggable === true) {
_.$list.addClass('draggable')
}
}
Slick.prototype.buildRows = function () {
var _ = this,
a,
b,
c,
newSlides,
numOfSlides,
originalSlides,
slidesPerSection
newSlides = document.createDocumentFragment()
originalSlides = _.$slider.children()
if (_.options.rows > 1) {
slidesPerSection = _.options.slidesPerRow * _.options.rows
numOfSlides = Math.ceil(originalSlides.length / slidesPerSection)
for (a = 0; a < numOfSlides; a++) {
var slide = document.createElement('div')
for (b = 0; b < _.options.rows; b++) {
var row = document.createElement('div')
for (c = 0; c < _.options.slidesPerRow; c++) {
var target =
a * slidesPerSection + (b * _.options.slidesPerRow + c)
if (originalSlides.get(target)) {
row.appendChild(originalSlides.get(target))
}
}
slide.appendChild(row)
}
newSlides.appendChild(slide)
}
_.$slider.empty().append(newSlides)
_.$slider
.children()
.children()
.children()
.css({
width: 100 / _.options.slidesPerRow + '%',
display: 'inline-block',
})
}
}
Slick.prototype.checkResponsive = function (initial, forceUpdate) {
var _ = this,
breakpoint,
targetBreakpoint,
respondToWidth,
triggerBreakpoint = false
var sliderWidth = _.$slider.width()
var windowWidth = window.innerWidth || $(window).width()
if (_.respondTo === 'window') {
respondToWidth = windowWidth
} else if (_.respondTo === 'slider') {
respondToWidth = sliderWidth
} else if (_.respondTo === 'min') {
respondToWidth = Math.min(windowWidth, sliderWidth)
}
if (
_.options.responsive &&
_.options.responsive.length &&
_.options.responsive !== null
) {
targetBreakpoint = null
for (breakpoint in _.breakpoints) {
if (_.breakpoints.hasOwnProperty(breakpoint)) {
if (_.originalSettings.mobileFirst === false) {
if (respondToWidth < _.breakpoints[breakpoint]) {
targetBreakpoint = _.breakpoints[breakpoint]
}
} else {
if (respondToWidth > _.breakpoints[breakpoint]) {
targetBreakpoint = _.breakpoints[breakpoint]
}
}
}
}
if (targetBreakpoint !== null) {
if (_.activeBreakpoint !== null) {
if (targetBreakpoint !== _.activeBreakpoint || forceUpdate) {
_.activeBreakpoint = targetBreakpoint
if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
_.unslick(targetBreakpoint)
} else {
_.options = $.extend(
{},
_.originalSettings,
_.breakpointSettings[targetBreakpoint]
)
if (initial === true) {
_.currentSlide = _.options.initialSlide
}
_.refresh(initial)
}
triggerBreakpoint = targetBreakpoint
}
} else {
_.activeBreakpoint = targetBreakpoint
if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
_.unslick(targetBreakpoint)
} else {
_.options = $.extend(
{},
_.originalSettings,
_.breakpointSettings[targetBreakpoint]
)
if (initial === true) {
_.currentSlide = _.options.initialSlide
}
_.refresh(initial)
}
triggerBreakpoint = targetBreakpoint
}
} else {
if (_.activeBreakpoint !== null) {
_.activeBreakpoint = null
_.options = _.originalSettings
if (initial === true) {
_.currentSlide = _.options.initialSlide
}
_.refresh(initial)
triggerBreakpoint = targetBreakpoint
}
}
// only trigger breakpoints during an actual break. not on initialize.
if (!initial && triggerBreakpoint !== false) {
_.$slider.trigger('breakpoint', [_, triggerBreakpoint])
}
}
}
Slick.prototype.changeSlide = function (event, dontAnimate) {
var _ = this,
$target = $(event.currentTarget),
indexOffset,
slideOffset,
unevenOffset
// If target is a link, prevent default action.
if ($target.is('a')) {
event.preventDefault()
}
// If target is not the <li> element (ie: a child), find the <li>.
if (!$target.is('li')) {
$target = $target.closest('li')
}
unevenOffset = _.slideCount % _.options.slidesToScroll !== 0
indexOffset = unevenOffset
? 0
: (_.slideCount - _.currentSlide) % _.options.slidesToScroll
switch (event.data.message) {
case 'previous':
slideOffset =
indexOffset === 0
? _.options.slidesToScroll
: _.options.slidesToShow - indexOffset
if (_.slideCount > _.options.slidesToShow) {
_.slideHandler(_.currentSlide - slideOffset, false, dontAnimate)
}
break
case 'next':
slideOffset =
indexOffset === 0 ? _.options.slidesToScroll : indexOffset
if (_.slideCount > _.options.slidesToShow) {
_.slideHandler(_.currentSlide + slideOffset, false, dontAnimate)
}
break
case 'index':
var index =
event.data.index === 0
? 0
: event.data.index || $target.index() * _.options.slidesToScroll
_.slideHandler(_.checkNavigable(index), false, dontAnimate)
$target.children().trigger('focus')
break
default:
return
}
}
Slick.prototype.checkNavigable = function (index) {
var _ = this,
navigables,
prevNavigable
navigables = _.getNavigableIndexes()
prevNavigable = 0
if (index > navigables[navigables.length - 1]) {
index = navigables[navigables.length - 1]
} else {
for (var n in navigables) {
if (index < navigables[n]) {
index = prevNavigable
break
}
prevNavigable = navigables[n]
}
}
return index
}
Slick.prototype.cleanUpEvents = function () {
var _ = this
if (_.options.dots && _.$dots !== null) {
$('li', _.$dots)
.off('click.slick', _.changeSlide)
.off('mouseenter.slick', $.proxy(_.interrupt, _, true))
.off('mouseleave.slick', $.proxy(_.interrupt, _, false))
if (_.options.accessibility === true) {
_.$dots.off('keydown.slick', _.keyHandler)
}
}
_.$slider.off('focus.slick blur.slick')
if (
_.options.arrows === true &&
_.slideCount > _.options.slidesToShow
) {
_.$prevArrow && _.$prevArrow.off('click.slick', _.changeSlide)
_.$nextArrow && _.$nextArrow.off('click.slick', _.changeSlide)
if (_.options.accessibility === true) {
_.$prevArrow && _.$prevArrow.off('keydown.slick', _.keyHandler)
_.$nextArrow && _.$nextArrow.off('keydown.slick', _.keyHandler)
}
}
_.$list.off('touchstart.slick mousedown.slick', _.swipeHandler)
_.$list.off('touchmove.slick mousemove.slick', _.swipeHandler)
_.$list.off('touchend.slick mouseup.slick', _.swipeHandler)
_.$list.off('touchcancel.slick mouseleave.slick', _.swipeHandler)
_.$list.off('click.slick', _.clickHandler)
$(document).off(_.visibilityChange, _.visibility)
_.cleanUpSlideEvents()
if (_.options.accessibility === true) {
_.$list.off('keydown.slick', _.keyHandler)
}
if (_.options.focusOnSelect === true) {
$(_.$slideTrack).children().off('click.slick', _.selectHandler)
}
$(window).off(
'orientationchange.slick.slick-' + _.instanceUid,
_.orientationChange
)
$(window).off('resize.slick.slick-' + _.instanceUid, _.resize)
$('[draggable!=true]', _.$slideTrack).off('dragstart', _.preventDefault)
$(window).off('load.slick.slick-' + _.instanceUid, _.setPosition)
}
Slick.prototype.cleanUpSlideEvents = function () {
var _ = this
_.$list.off('mouseenter.slick', $.proxy(_.interrupt, _, true))
_.$list.off('mouseleave.slick', $.proxy(_.interrupt, _, false))
}
Slick.prototype.cleanUpRows = function () {
var _ = this,
originalSlides
if (_.options.rows > 1) {
originalSlides = _.$slides.children().children()
originalSlides.removeAttr('style')
_.$slider.empty().append(originalSlides)
}
}
Slick.prototype.clickHandler = function (event) {
var _ = this
if (_.shouldClick === false) {
event.stopImmediatePropagation()
event.stopPropagation()
event.preventDefault()
}
}
Slick.prototype.destroy = function (refresh) {
var _ = this
_.autoPlayClear()
_.touchObject = {}
_.cleanUpEvents()
$('.slick-cloned', _.$slider).detach()
if (_.$dots) {
_.$dots.remove()
}
if (_.$prevArrow && _.$prevArrow.length) {
_.$prevArrow
.removeClass('slick-disabled slick-arrow slick-hidden')
.removeAttr('aria-hidden aria-disabled tabindex')
.css('display', '')
if (_.htmlExpr.test(_.options.prevArrow)) {
_.$prevArrow.remove()
}
}
if (_.$nextArrow && _.$nextArrow.length) {
_.$nextArrow
.removeClass('slick-disabled slick-arrow slick-hidden')
.removeAttr('aria-hidden aria-disabled tabindex')
.css('display', '')
if (_.htmlExpr.test(_.options.nextArrow)) {
_.$nextArrow.remove()
}
}
if (_.$slides) {
_.$slides
.removeClass(
'slick-slide slick-active slick-center slick-visible slick-current'
)
.removeAttr('aria-hidden')
.removeAttr('data-slick-index')
.each(function () {
$(this).attr('style', $(this).data('originalStyling'))
})
_.$slideTrack.children(this.options.slide).detach()
_.$slideTrack.detach()
_.$list.detach()
_.$slider.append(_.$slides)
}
_.cleanUpRows()
_.$slider.removeClass('slick-slider')
_.$slider.removeClass('slick-initialized')
_.$slider.removeClass('slick-dotted')
_.unslicked = true
if (!refresh) {
_.$slider.trigger('destroy', [_])
}
}
Slick.prototype.disableTransition = function (slide) {
var _ = this,
transition = {}
transition[_.transitionType] = ''
if (_.options.fade === false) {
_.$slideTrack.css(transition)
} else {
_.$slides.eq(slide).css(transition)
}
}
Slick.prototype.fadeSlide = function (slideIndex, callback) {
var _ = this
if (_.cssTransitions === false) {
_.$slides.eq(slideIndex).css({
zIndex: _.options.zIndex,
})
_.$slides.eq(slideIndex).animate(
{
opacity: 1,
},
_.options.speed,
_.options.easing,
callback
)
} else {
_.applyTransition(slideIndex)
_.$slides.eq(slideIndex).css({
opacity: 1,
zIndex: _.options.zIndex,
})
if (callback) {
setTimeout(function () {
_.disableTransition(slideIndex)
callback.call()
}, _.options.speed)
}
}
}
Slick.prototype.fadeSlideOut = function (slideIndex) {
var _ = this
if (_.cssTransitions === false) {
_.$slides.eq(slideIndex).animate(
{
opacity: 0,
zIndex: _.options.zIndex - 2,
},
_.options.speed,
_.options.easing
)
} else {
_.applyTransition(slideIndex)
_.$slides.eq(slideIndex).css({
opacity: 0,
zIndex: _.options.zIndex - 2,
})
}
}
Slick.prototype.filterSlides = Slick.prototype.slickFilter = function (
filter
) {
var _ = this
if (filter !== null) {
_.$slidesCache = _.$slides
_.unload()
_.$slideTrack.children(this.options.slide).detach()
_.$slidesCache.filter(filter).appendTo(_.$slideTrack)
_.reinit()
}
}
Slick.prototype.focusHandler = function () {
var _ = this
_.$slider
.off('focus.slick blur.slick')
.on('focus.slick blur.slick', '*', function (event) {
event.stopImmediatePropagation()
var $sf = $(this)
setTimeout(function () {
if (_.options.pauseOnFocus) {
_.focussed = $sf.is(':focus')
_.autoPlay()
}
}, 0)
})
}
Slick.prototype.getCurrent = Slick.prototype.slickCurrentSlide =
function () {
var _ = this
return _.currentSlide
}
Slick.prototype.getDotCount = function () {
var _ = this
var breakPoint = 0
var counter = 0
var pagerQty = 0
if (_.options.infinite === true) {
if (_.slideCount <= _.options.slidesToShow) {
++pagerQty
} else {
while (breakPoint < _.slideCount) {
++pagerQty
breakPoint = counter + _.options.slidesToScroll
counter +=
_.options.slidesToScroll <= _.options.slidesToShow
? _.options.slidesToScroll
: _.options.slidesToShow
}
}
} else if (_.options.centerMode === true) {
pagerQty = _.slideCount
} else if (!_.options.asNavFor) {
pagerQty =
1 +
Math.ceil(
(_.slideCount - _.options.slidesToShow) / _.options.slidesToScroll
)
} else {
while (breakPoint < _.slideCount) {
++pagerQty
breakPoint = counter + _.options.slidesToScroll
counter +=
_.options.slidesToScroll <= _.options.slidesToShow
? _.options.slidesToScroll
: _.options.slidesToShow
}
}
return pagerQty - 1
}
Slick.prototype.getLeft = function (slideIndex) {
var _ = this,
targetLeft,
verticalHeight,
verticalOffset = 0,
targetSlide,
coef
_.slideOffset = 0
verticalHeight = _.$slides.first().outerHeight(true)
if (_.options.infinite === true) {
if (_.slideCount > _.options.slidesToShow) {
_.slideOffset = _.slideWidth * _.options.slidesToShow * -1
coef = -1
if (_.options.vertical === true && _.options.centerMode === true) {
if (_.options.slidesToShow === 2) {
coef = -1.5
} else if (_.options.slidesToShow === 1) {
coef = -2
}
}
verticalOffset = verticalHeight * _.options.slidesToShow * coef
}
if (_.slideCount % _.options.slidesToScroll !== 0) {
if (
slideIndex + _.options.slidesToScroll > _.slideCount &&
_.slideCount > _.options.slidesToShow
) {
if (slideIndex > _.slideCount) {
_.slideOffset =
(_.options.slidesToShow - (slideIndex - _.slideCount)) *
_.slideWidth *
-1
verticalOffset =
(_.options.slidesToShow - (slideIndex - _.slideCount)) *
verticalHeight *
-1
} else {
_.slideOffset =
(_.slideCount % _.options.slidesToScroll) * _.slideWidth * -1
verticalOffset =
(_.slideCount % _.options.slidesToScroll) *
verticalHeight *
-1
}
}
}
} else {
if (slideIndex + _.options.slidesToShow > _.slideCount) {
_.slideOffset =
(slideIndex + _.options.slidesToShow - _.slideCount) *
_.slideWidth
verticalOffset =
(slideIndex + _.options.slidesToShow - _.slideCount) *
verticalHeight
}
}
if (_.slideCount <= _.options.slidesToShow) {
_.slideOffset = 0
verticalOffset = 0
}
if (
_.options.centerMode === true &&
_.slideCount <= _.options.slidesToShow
) {
_.slideOffset =
(_.slideWidth * Math.floor(_.options.slidesToShow)) / 2 -
(_.slideWidth * _.slideCount) / 2
} else if (
_.options.centerMode === true &&
_.options.infinite === true
) {
_.slideOffset +=
_.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth
} else if (_.options.centerMode === true) {
_.slideOffset = 0
_.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2)
}
if (_.options.vertical === false) {
targetLeft = slideIndex * _.slideWidth * -1 + _.slideOffset
} else {
targetLeft = slideIndex * verticalHeight * -1 + verticalOffset
}
if (_.options.variableWidth === true) {
if (
_.slideCount <= _.options.slidesToShow ||
_.options.infinite === false
) {
targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex)
} else {
targetSlide = _.$slideTrack
.children('.slick-slide')
.eq(slideIndex + _.options.slidesToShow)
}
if (_.options.rtl === true) {
if (targetSlide[0]) {
targetLeft =
(_.$slideTrack.width() -
targetSlide[0].offsetLeft -
targetSlide.width()) *
-1
} else {
targetLeft = 0
}
} else {
targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0
}
if (_.options.centerMode === true) {
if (
_.slideCount <= _.options.slidesToShow ||
_.options.infinite === false
) {
targetSlide = _.$slideTrack
.children('.slick-slide')
.eq(slideIndex)
} else {
targetSlide = _.$slideTrack
.children('.slick-slide')
.eq(slideIndex + _.options.slidesToShow + 1)
}
if (_.options.rtl === true) {
if (targetSlide[0]) {
targetLeft =
(_.$slideTrack.width() -
targetSlide[0].offsetLeft -
targetSlide.width()) *
-1
} else {
targetLeft = 0
}
} else {
targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0
}
targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2
}
}
return targetLeft
}
Slick.prototype.getOption = Slick.prototype.slickGetOption = function (
option
) {
var _ = this
return _.options[option]
}
Slick.prototype.getNavigableIndexes = function () {
var _ = this,
breakPoint = 0,
counter = 0,
indexes = [],
max
if (_.options.infinite === false) {
max = _.slideCount
} else {
breakPoint = _.options.slidesToScroll * -1
counter = _.options.slidesToScroll * -1
max = _.slideCount * 2
}
while (breakPoint < max) {
indexes.push(breakPoint)
breakPoint = counter + _.options.slidesToScroll
counter +=
_.options.slidesToScroll <= _.options.slidesToShow
? _.options.slidesToScroll
: _.options.slidesToShow
}
return indexes
}
Slick.prototype.getSlick = function () {
return this
}
Slick.prototype.getSlideCount = function () {
var _ = this,
slidesTraversed,
swipedSlide,
centerOffset
centerOffset =
_.options.centerMode === true
? _.slideWidth * Math.floor(_.options.slidesToShow / 2)
: 0
if (_.options.swipeToSlide === true) {
_.$slideTrack.find('.slick-slide').each(function (index, slide) {
if (
slide.offsetLeft - centerOffset + $(slide).outerWidth() / 2 >
_.swipeLeft * -1
) {
swipedSlide = slide
return false
}
})
slidesTraversed =
Math.abs(
$(swipedSlide).attr('data-slick-index') - _.currentSlide
) || 1
return slidesTraversed
} else {
return _.options.slidesToScroll
}
}
Slick.prototype.goTo = Slick.prototype.slickGoTo = function (
slide,
dontAnimate
) {
var _ = this
_.changeSlide(
{
data: {
message: 'index',
index: parseInt(slide),
},
},
dontAnimate
)
}
Slick.prototype.init = function (creation) {
var _ = this
if (!$(_.$slider).hasClass('slick-initialized')) {
$(_.$slider).addClass('slick-initialized')
_.buildRows()
_.buildOut()
_.setProps()
_.startLoad()
_.loadSlider()
_.initializeEvents()
_.updateArrows()
_.updateDots()
_.checkResponsive(true)
_.focusHandler()
}
if (creation) {
_.$slider.trigger('init', [_])
}
if (_.options.accessibility === true) {
_.initADA()
}
if (_.options.autoplay) {
_.paused = false
_.autoPlay()
}
}
Slick.prototype.initADA = function () {
var _ = this,
numDotGroups = Math.ceil(_.slideCount / _.options.slidesToShow),
tabControlIndexes = _.getNavigableIndexes().filter(function (val) {
return val >= 0 && val < _.slideCount
})
if (_.$slides) {
_.$slides
.add(_.$slideTrack.find('.slick-cloned'))
.attr({
'aria-hidden': 'true',
tabindex: '-1',
})
.find('a, input, button, select')
.attr({
tabindex: '-1',
})
}
if (_.$dots !== null) {
_.$slides.not(_.$slideTrack.find('.slick-cloned')).each(function (i) {
var slideControlIndex = tabControlIndexes.indexOf(i)
$(this).attr({
role: 'tabpanel',
id: 'slick-slide' + _.instanceUid + i,
tabindex: -1,
})
if (slideControlIndex !== -1) {
$(this).attr({
'aria-describedby':
'slick-slide-control' + _.instanceUid + slideControlIndex,
})
}
})
_.$dots
.attr('role', 'tablist')
.find('li')
.each(function (i) {
var mappedSlideIndex = tabControlIndexes[i]
$(this).attr({
role: 'presentation',
})
$(this)
.find('button')
.first()
.attr({
role: 'tab',
id: 'slick-slide-control' + _.instanceUid + i,
'aria-controls':
'slick-slide' + _.instanceUid + mappedSlideIndex,
'aria-label': i + 1 + ' of ' + numDotGroups,
'aria-selected': null,
tabindex: '-1',
})
})
.eq(_.currentSlide)
.find('button')
.attr({
'aria-selected': 'true',
tabindex: '0',
})
.end()
}
if (_.$slides) {
for (
var i = _.currentSlide, max = i + _.options.slidesToShow;
i < max;
i++
) {
_.$slides.eq(i).attr('tabindex', 0)
}
}
_.activateADA()
}
Slick.prototype.initArrowEvents = function () {
var _ = this
if (
_.options.arrows === true &&
_.slideCount > _.options.slidesToShow
) {
_.$prevArrow.off('click.slick').on(
'click.slick',
{
message: 'previous',
},
_.changeSlide
)
_.$nextArrow.off('click.slick').on(
'click.slick',
{
message: 'next',
},
_.changeSlide
)
if (_.options.accessibility === true) {
_.$prevArrow.on('keydown.slick', _.keyHandler)
_.$nextArrow.on('keydown.slick', _.keyHandler)
}
}
}
Slick.prototype.initDotEvents = function () {
var _ = this
if (_.options.dots === true) {
$('li', _.$dots).on(
'click.slick',
{
message: 'index',
},
_.changeSlide
)
if (_.options.accessibility === true) {
_.$dots.on('keydown.slick', _.keyHandler)
}
}
if (_.options.dots === true && _.options.pauseOnDotsHover === true) {
$('li', _.$dots)
.on('mouseenter.slick', $.proxy(_.interrupt, _, true))
.on('mouseleave.slick', $.proxy(_.interrupt, _, false))
}
}
Slick.prototype.initSlideEvents = function () {
var _ = this
if (_.options.pauseOnHover) {
_.$list.on('mouseenter.slick', $.proxy(_.interrupt, _, true))
_.$list.on('mouseleave.slick', $.proxy(_.interrupt, _, false))
}
}
Slick.prototype.initializeEvents = function () {
var _ = this
_.initArrowEvents()
_.initDotEvents()
_.initSlideEvents()
_.$list.on(
'touchstart.slick mousedown.slick',
{
action: 'start',
},
_.swipeHandler
)
_.$list.on(
'touchmove.slick mousemove.slick',
{
action: 'move',
},
_.swipeHandler
)
_.$list.on(
'touchend.slick mouseup.slick',
{
action: 'end',
},
_.swipeHandler
)
_.$list.on(
'touchcancel.slick mouseleave.slick',
{
action: 'end',
},
_.swipeHandler
)
_.$list.on('click.slick', _.clickHandler)
$(document).on(_.visibilityChange, $.proxy(_.visibility, _))
if (_.options.accessibility === true) {
_.$list.on('keydown.slick', _.keyHandler)
}
if (_.options.focusOnSelect === true) {
$(_.$slideTrack).children().on('click.slick', _.selectHandler)
}
$(window).on(
'orientationchange.slick.slick-' + _.instanceUid,
$.proxy(_.orientationChange, _)
)
$(window).on(
'resize.slick.slick-' + _.instanceUid,
$.proxy(_.resize, _)
)
$('[draggable!=true]', _.$slideTrack).on('dragstart', _.preventDefault)
$(window).on('load.slick.slick-' + _.instanceUid, _.setPosition)
$(_.setPosition)
}
Slick.prototype.initUI = function () {
var _ = this
if (
_.options.arrows === true &&
_.slideCount > _.options.slidesToShow
) {
_.$prevArrow.show()
_.$nextArrow.show()
}
if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
_.$dots.show()
}
}
Slick.prototype.keyHandler = function (event) {
var _ = this
//Dont slide if the cursor is inside the form fields and arrow keys are pressed
if (!event.target.tagName.match('TEXTAREA|INPUT|SELECT')) {
if (event.keyCode === 37 && _.options.accessibility === true) {
_.changeSlide({
data: {
message: _.options.rtl === true ? 'next' : 'previous',
},
})
} else if (event.keyCode === 39 && _.options.accessibility === true) {
_.changeSlide({
data: {
message: _.options.rtl === true ? 'previous' : 'next',
},
})
}
}
}
Slick.prototype.lazyLoad = function () {
var _ = this,
loadRange,
cloneRange,
rangeStart,
rangeEnd
function loadImages(imagesScope) {
$('img[data-lazy]', imagesScope).each(function () {
var image = $(this),
imageSource = $(this).attr('data-lazy'),
imageSrcSet = $(this).attr('data-srcset'),
imageSizes =
$(this).attr('data-sizes') || _.$slider.attr('data-sizes'),
imageToLoad = document.createElement('img')
imageToLoad.onload = function () {
image.animate(
{
opacity: 0,
},
100,
function () {
if (imageSrcSet) {
image.attr('srcset', imageSrcSet)
if (imageSizes) {
image.attr('sizes', imageSizes)
}
}
image.attr('src', imageSource).animate(
{
opacity: 1,
},
200,
function () {
image
.removeAttr('data-lazy data-srcset data-sizes')
.removeClass('slick-loading')
}
)
_.$slider.trigger('lazyLoaded', [_, image, imageSource])
}
)
}
imageToLoad.onerror = function () {
image
.removeAttr('data-lazy')
.removeClass('slick-loading')
.addClass('slick-lazyload-error')
_.$slider.trigger('lazyLoadError', [_, image, imageSource])
}
imageToLoad.src = imageSource
})
}
if (_.options.centerMode === true) {
if (_.options.infinite === true) {
rangeStart = _.currentSlide + (_.options.slidesToShow / 2 + 1)
rangeEnd = rangeStart + _.options.slidesToShow + 2
} else {
rangeStart = Math.max(
0,
_.currentSlide - (_.options.slidesToShow / 2 + 1)
)
rangeEnd = 2 + (_.options.slidesToShow / 2 + 1) + _.currentSlide
}
} else {
rangeStart = _.options.infinite
? _.options.slidesToShow + _.currentSlide
: _.currentSlide
rangeEnd = Math.ceil(rangeStart + _.options.slidesToShow)
if (_.options.fade === true) {
if (rangeStart > 0) rangeStart--
if (rangeEnd <= _.slideCount) rangeEnd++
}
}
loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd)
if (_.options.lazyLoad === 'anticipated') {
var prevSlide = rangeStart - 1,
nextSlide = rangeEnd,
$slides = _.$slider.find('.slick-slide')
for (var i = 0; i < _.options.slidesToScroll; i++) {
if (prevSlide < 0) prevSlide = _.slideCount - 1
loadRange = loadRange.add($slides.eq(prevSlide))
loadRange = loadRange.add($slides.eq(nextSlide))
prevSlide--
nextSlide++
}
}
loadImages(loadRange)
if (_.slideCount <= _.options.slidesToShow) {
cloneRange = _.$slider.find('.slick-slide')
loadImages(cloneRange)
} else if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
cloneRange = _.$slider
.find('.slick-cloned')
.slice(0, _.options.slidesToShow)
loadImages(cloneRange)
} else if (_.currentSlide === 0) {
cloneRange = _.$slider
.find('.slick-cloned')
.slice(_.options.slidesToShow * -1)
loadImages(cloneRange)
}
}
Slick.prototype.loadSlider = function () {
var _ = this
_.setPosition()
_.$slideTrack.css({
opacity: 1,
})
_.$slider.removeClass('slick-loading')
_.initUI()
if (_.options.lazyLoad === 'progressive') {
_.progressiveLazyLoad()
}
}
Slick.prototype.next = Slick.prototype.slickNext = function () {
var _ = this
_.changeSlide({
data: {
message: 'next',
},
})
}
Slick.prototype.orientationChange = function () {
var _ = this
_.checkResponsive()
_.setPosition()
}
Slick.prototype.pause = Slick.prototype.slickPause = function () {
var _ = this
_.autoPlayClear()
_.paused = true
}
Slick.prototype.play = Slick.prototype.slickPlay = function () {
var _ = this
_.autoPlay()
_.options.autoplay = true
_.paused = false
_.focussed = false
_.interrupted = false
}
Slick.prototype.postSlide = function (index) {
var _ = this
if (!_.unslicked) {
_.$slider.trigger('afterChange', [_, index])
_.animating = false
if (_.slideCount > _.options.slidesToShow) {
_.setPosition()
}
_.swipeLeft = null
if (_.options.autoplay) {
_.autoPlay()
}
if (_.options.accessibility === true) {
_.initADA()
if (_.options.focusOnChange) {
var $currentSlide = $(_.$slides.get(_.currentSlide))
$currentSlide.attr('tabindex', 0).focus()
}
}
}
}
Slick.prototype.prev = Slick.prototype.slickPrev = function () {
var _ = this
_.changeSlide({
data: {
message: 'previous',
},
})
}
Slick.prototype.preventDefault = function (event) {
event.preventDefault()
}
Slick.prototype.progressiveLazyLoad = function (tryCount) {
tryCount = tryCount || 1
var _ = this,
$imgsToLoad = $('img[data-lazy]', _.$slider),
image,
imageSource,
imageSrcSet,
imageSizes,
imageToLoad
if ($imgsToLoad.length) {
image = $imgsToLoad.first()
imageSource = image.attr('data-lazy')
imageSrcSet = image.attr('data-srcset')
imageSizes = image.attr('data-sizes') || _.$slider.attr('data-sizes')
imageToLoad = document.createElement('img')
imageToLoad.onload = function () {
if (imageSrcSet) {
image.attr('srcset', imageSrcSet)
if (imageSizes) {
image.attr('sizes', imageSizes)
}
}
image
.attr('src', imageSource)
.removeAttr('data-lazy data-srcset data-sizes')
.removeClass('slick-loading')
if (_.options.adaptiveHeight === true) {
_.setPosition()
}
_.$slider.trigger('lazyLoaded', [_, image, imageSource])
_.progressiveLazyLoad()
}
imageToLoad.onerror = function () {
if (tryCount < 3) {
/**
* try to load the image 3 times,
* leave a slight delay so we don't get
* servers blocking the request.
*/
setTimeout(function () {
_.progressiveLazyLoad(tryCount + 1)
}, 500)
} else {
image
.removeAttr('data-lazy')
.removeClass('slick-loading')
.addClass('slick-lazyload-error')
_.$slider.trigger('lazyLoadError', [_, image, imageSource])
_.progressiveLazyLoad()
}
}
imageToLoad.src = imageSource
} else {
_.$slider.trigger('allImagesLoaded', [_])
}
}
Slick.prototype.refresh = function (initializing) {
var _ = this,
currentSlide,
lastVisibleIndex
lastVisibleIndex = _.slideCount - _.options.slidesToShow
// in non-infinite sliders, we don't want to go past the
// last visible index.
if (!_.options.infinite && _.currentSlide > lastVisibleIndex) {
_.currentSlide = lastVisibleIndex
}
// if less slides than to show, go to start.
if (_.slideCount <= _.options.slidesToShow) {
_.currentSlide = 0
}
currentSlide = _.currentSlide
_.destroy(true)
$.extend(_, _.initials, {
currentSlide: currentSlide,
})
_.init()
if (!initializing) {
_.changeSlide(
{
data: {
message: 'index',
index: currentSlide,
},
},
false
)
}
}
Slick.prototype.registerBreakpoints = function () {
var _ = this,
breakpoint,
currentBreakpoint,
l,
responsiveSettings = _.options.responsive || null
if (
$.type(responsiveSettings) === 'array' &&
responsiveSettings.length
) {
_.respondTo = _.options.respondTo || 'window'
for (breakpoint in responsiveSettings) {
l = _.breakpoints.length - 1
if (responsiveSettings.hasOwnProperty(breakpoint)) {
currentBreakpoint = responsiveSettings[breakpoint].breakpoint
// loop through the breakpoints and cut out any existing
// ones with the same breakpoint number, we don't want dupes.
while (l >= 0) {
if (
_.breakpoints[l] &&
_.breakpoints[l] === currentBreakpoint
) {
_.breakpoints.splice(l, 1)
}
l--
}
_.breakpoints.push(currentBreakpoint)
_.breakpointSettings[currentBreakpoint] =
responsiveSettings[breakpoint].settings
}
}
_.breakpoints.sort(function (a, b) {
return _.options.mobileFirst ? a - b : b - a
})
}
}
Slick.prototype.reinit = function () {
var _ = this
_.$slides = _.$slideTrack
.children(_.options.slide)
.addClass('slick-slide')
_.slideCount = _.$slides.length
if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
_.currentSlide = _.currentSlide - _.options.slidesToScroll
}
if (_.slideCount <= _.options.slidesToShow) {
_.currentSlide = 0
}
_.registerBreakpoints()
_.setProps()
_.setupInfinite()
_.buildArrows()
_.updateArrows()
_.initArrowEvents()
_.buildDots()
_.updateDots()
_.initDotEvents()
_.cleanUpSlideEvents()
_.initSlideEvents()
_.checkResponsive(false, true)
if (_.options.focusOnSelect === true) {
$(_.$slideTrack).children().on('click.slick', _.selectHandler)
}
_.setSlideClasses(
typeof _.currentSlide === 'number' ? _.currentSlide : 0
)
_.setPosition()
_.focusHandler()
_.paused = !_.options.autoplay
_.autoPlay()
_.$slider.trigger('reInit', [_])
}
Slick.prototype.resize = function () {
var _ = this
if ($(window).width() !== _.windowWidth) {
clearTimeout(_.windowDelay)
_.windowDelay = window.setTimeout(function () {
_.windowWidth = $(window).width()
_.checkResponsive()
if (!_.unslicked) {
_.setPosition()
}
}, 50)
}
}
Slick.prototype.removeSlide = Slick.prototype.slickRemove = function (
index,
removeBefore,
removeAll
) {
var _ = this
if (typeof index === 'boolean') {
removeBefore = index
index = removeBefore === true ? 0 : _.slideCount - 1
} else {
index = removeBefore === true ? --index : index
}
if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
return false
}
_.unload()
if (removeAll === true) {
_.$slideTrack.children().remove()
} else {
_.$slideTrack.children(this.options.slide).eq(index).remove()
}
_.$slides = _.$slideTrack.children(this.options.slide)
_.$slideTrack.children(this.options.slide).detach()
_.$slideTrack.append(_.$slides)
_.$slidesCache = _.$slides
_.reinit()
}
Slick.prototype.setCSS = function (position) {
var _ = this,
positionProps = {},
x,
y
if (_.options.rtl === true) {
position = -position
}
x = _.positionProp == 'left' ? Math.ceil(position) + 'px' : '0px'
y = _.positionProp == 'top' ? Math.ceil(position) + 'px' : '0px'
positionProps[_.positionProp] = position
if (_.transformsEnabled === false) {
_.$slideTrack.css(positionProps)
} else {
positionProps = {}
if (_.cssTransitions === false) {
positionProps[_.animType] = 'translate(' + x + ', ' + y + ')'
_.$slideTrack.css(positionProps)
} else {
positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)'
_.$slideTrack.css(positionProps)
}
}
}
Slick.prototype.setDimensions = function () {
var _ = this
if (_.options.vertical === false) {
if (_.options.centerMode === true) {
_.$list.css({
padding: '0px ' + _.options.centerPadding,
})
}
} else {
// THANHNT fix height at decimal value
_.$list.height(
parseInt(
_.$slides.first()[0].getBoundingClientRect().height *
_.options.slidesToShow
)
)
// _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);
if (_.options.centerMode === true) {
_.$list.css({
padding: _.options.centerPadding + ' 0px',
})
}
}
_.listWidth = _.$list.width()
_.listHeight = _.$list.height()
if (_.options.vertical === false && _.options.variableWidth === false) {
//THANHNT fix width at decimal value
// _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
_.slideWidth =
Math.ceil((_.listWidth / _.options.slidesToShow) * 100) / 100
_.$slideTrack.width(
Math.ceil(
_.slideWidth * _.$slideTrack.children('.slick-slide').length
)
)
} else if (_.options.variableWidth === true) {
_.$slideTrack.width(5000 * _.slideCount)
} else {
_.slideWidth = Math.ceil(_.listWidth)
_.$slideTrack.height(
Math.ceil(
_.$slides.first().outerHeight(true) *
_.$slideTrack.children('.slick-slide').length
)
)
}
var offset =
_.$slides.first().outerWidth(true) - _.$slides.first().width()
if (_.options.variableWidth === false)
_.$slideTrack.children('.slick-slide').width(_.slideWidth - offset)
}
Slick.prototype.setFade = function () {
var _ = this,
targetLeft
_.$slides.each(function (index, element) {
targetLeft = _.slideWidth * index * -1
if (_.options.rtl === true) {
$(element).css({
position: 'relative',
right: targetLeft,
top: 0,
zIndex: _.options.zIndex - 2,
opacity: 0,
})
} else {
$(element).css({
position: 'relative',
left: targetLeft,
top: 0,
zIndex: _.options.zIndex - 2,
opacity: 0,
})
}
})
_.$slides.eq(_.currentSlide).css({
zIndex: _.options.zIndex - 1,
opacity: 1,
})
}
Slick.prototype.setHeight = function () {
var _ = this
if (
_.options.slidesToShow === 1 &&
_.options.adaptiveHeight === true &&
_.options.vertical === false
) {
var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true)
_.$list.css('height', targetHeight)
}
}
Slick.prototype.setOption = Slick.prototype.slickSetOption = function () {
/**
* accepts arguments in format of:
*
* - for changing a single option's value:
* .slick("setOption", option, value, refresh )
*
* - for changing a set of responsive options:
* .slick("setOption", 'responsive', [{}, ...], refresh )
*
* - for updating multiple values at once (not responsive)
* .slick("setOption", { 'option': value, ... }, refresh )
*/
var _ = this,
l,
item,
option,
value,
refresh = false,
type
if ($.type(arguments[0]) === 'object') {
option = arguments[0]
refresh = arguments[1]
type = 'multiple'
} else if ($.type(arguments[0]) === 'string') {
option = arguments[0]
value = arguments[1]
refresh = arguments[2]
if (
arguments[0] === 'responsive' &&
$.type(arguments[1]) === 'array'
) {
type = 'responsive'
} else if (typeof arguments[1] !== 'undefined') {
type = 'single'
}
}
if (type === 'single') {
_.options[option] = value
} else if (type === 'multiple') {
$.each(option, function (opt, val) {
_.options[opt] = val
})
} else if (type === 'responsive') {
for (item in value) {
if ($.type(_.options.responsive) !== 'array') {
_.options.responsive = [value[item]]
} else {
l = _.options.responsive.length - 1
// loop through the responsive object and splice out duplicates.
while (l >= 0) {
if (
_.options.responsive[l].breakpoint === value[item].breakpoint
) {
_.options.responsive.splice(l, 1)
}
l--
}
_.options.responsive.push(value[item])
}
}
}
if (refresh) {
_.unload()
_.reinit()
}
}
Slick.prototype.setPosition = function () {
var _ = this
_.setDimensions()
_.setHeight()
if (_.options.fade === false) {
_.setCSS(_.getLeft(_.currentSlide))
} else {
_.setFade()
}
_.$slider.trigger('setPosition', [_])
}
Slick.prototype.setProps = function () {
var _ = this,
bodyStyle = document.body.style
_.positionProp = _.options.vertical === true ? 'top' : 'left'
if (_.positionProp === 'top') {
_.$slider.addClass('slick-vertical')
} else {
_.$slider.removeClass('slick-vertical')
}
if (
bodyStyle.WebkitTransition !== undefined ||
bodyStyle.MozTransition !== undefined ||
bodyStyle.msTransition !== undefined
) {
if (_.options.useCSS === true) {
_.cssTransitions = true
}
}
if (_.options.fade) {
if (typeof _.options.zIndex === 'number') {
if (_.options.zIndex < 3) {
_.options.zIndex = 3
}
} else {
_.options.zIndex = _.defaults.zIndex
}
}
if (bodyStyle.OTransform !== undefined) {
_.animType = 'OTransform'
_.transformType = '-o-transform'
_.transitionType = 'OTransition'
if (
bodyStyle.perspectiveProperty === undefined &&
bodyStyle.webkitPerspective === undefined
)
_.animType = false
}
if (bodyStyle.MozTransform !== undefined) {
_.animType = 'MozTransform'
_.transformType = '-moz-transform'
_.transitionType = 'MozTransition'
if (
bodyStyle.perspectiveProperty === undefined &&
bodyStyle.MozPerspective === undefined
)
_.animType = false
}
if (bodyStyle.webkitTransform !== undefined) {
_.animType = 'webkitTransform'
_.transformType = '-webkit-transform'
_.transitionType = 'webkitTransition'
if (
bodyStyle.perspectiveProperty === undefined &&
bodyStyle.webkitPerspective === undefined
)
_.animType = false
}
if (bodyStyle.msTransform !== undefined) {
_.animType = 'msTransform'
_.transformType = '-ms-transform'
_.transitionType = 'msTransition'
if (bodyStyle.msTransform === undefined) _.animType = false
}
if (bodyStyle.transform !== undefined && _.animType !== false) {
_.animType = 'transform'
_.transformType = 'transform'
_.transitionType = 'transition'
}
_.transformsEnabled =
_.options.useTransform && _.animType !== null && _.animType !== false
}
Slick.prototype.setSlideClasses = function (index) {
var _ = this,
centerOffset,
allSlides,
indexOffset,
remainder
allSlides = _.$slider
.find('.slick-slide')
.removeClass('slick-active slick-center slick-current')
.attr('aria-hidden', 'true')
_.$slides.eq(index).addClass('slick-current')
if (_.options.centerMode === true) {
var evenCoef = _.options.slidesToShow % 2 === 0 ? 1 : 0
centerOffset = Math.floor(_.options.slidesToShow / 2)
if (_.options.infinite === true) {
if (
index >= centerOffset &&
index <= _.slideCount - 1 - centerOffset
) {
_.$slides
.slice(
index - centerOffset + evenCoef,
index + centerOffset + 1
)
.addClass('slick-active')
.attr('aria-hidden', 'false')
} else {
indexOffset = _.options.slidesToShow + index
allSlides
.slice(
indexOffset - centerOffset + 1 + evenCoef,
indexOffset + centerOffset + 2
)
.addClass('slick-active')
.attr('aria-hidden', 'false')
}
if (index === 0) {
allSlides
.eq(allSlides.length - 1 - _.options.slidesToShow)
.addClass('slick-center')
} else if (index === _.slideCount - 1) {
allSlides.eq(_.options.slidesToShow).addClass('slick-center')
}
}
_.$slides.eq(index).addClass('slick-center')
} else {
if (index >= 0 && index <= _.slideCount - _.options.slidesToShow) {
_.$slides
.slice(index, index + _.options.slidesToShow)
.addClass('slick-active')
.attr('aria-hidden', 'false')
} else if (allSlides.length <= _.options.slidesToShow) {
allSlides.addClass('slick-active').attr('aria-hidden', 'false')
} else {
remainder = _.slideCount % _.options.slidesToShow
indexOffset =
_.options.infinite === true
? _.options.slidesToShow + index
: index
if (
_.options.slidesToShow == _.options.slidesToScroll &&
_.slideCount - index < _.options.slidesToShow
) {
allSlides
.slice(
indexOffset - (_.options.slidesToShow - remainder),
indexOffset + remainder
)
.addClass('slick-active')
.attr('aria-hidden', 'false')
} else {
allSlides
.slice(indexOffset, indexOffset + _.options.slidesToShow)
.addClass('slick-active')
.attr('aria-hidden', 'false')
}
}
}
if (
_.options.lazyLoad === 'ondemand' ||
_.options.lazyLoad === 'anticipated'
) {
_.lazyLoad()
}
}
Slick.prototype.setupInfinite = function () {
var _ = this,
i,
slideIndex,
infiniteCount
if (_.options.fade === true) {
_.options.centerMode = false
}
if (_.options.infinite === true && _.options.fade === false) {
slideIndex = null
if (_.slideCount > _.options.slidesToShow) {
if (_.options.centerMode === true) {
infiniteCount = _.options.slidesToShow + 1
} else {
infiniteCount = _.options.slidesToShow
}
for (i = _.slideCount; i > _.slideCount - infiniteCount; i -= 1) {
slideIndex = i - 1
$(_.$slides[slideIndex])
.clone(true)
.attr('id', '')
.attr('data-slick-index', slideIndex - _.slideCount)
.prependTo(_.$slideTrack)
.addClass('slick-cloned')
}
for (i = 0; i < infiniteCount + _.slideCount; i += 1) {
slideIndex = i
$(_.$slides[slideIndex])
.clone(true)
.attr('id', '')
.attr('data-slick-index', slideIndex + _.slideCount)
.appendTo(_.$slideTrack)
.addClass('slick-cloned')
}
_.$slideTrack
.find('.slick-cloned')
.find('[id]')
.each(function () {
$(this).attr('id', '')
})
}
}
}
Slick.prototype.interrupt = function (toggle) {
var _ = this
if (!toggle) {
_.autoPlay()
}
_.interrupted = toggle
}
Slick.prototype.selectHandler = function (event) {
var _ = this
var targetElement = $(event.target).is('.slick-slide')
? $(event.target)
: $(event.target).parents('.slick-slide')
var index = parseInt(targetElement.attr('data-slick-index'))
if (!index) index = 0
if (_.slideCount <= _.options.slidesToShow) {
_.slideHandler(index, false, true)
return
}
_.slideHandler(index)
}
Slick.prototype.slideHandler = function (index, sync, dontAnimate) {
var targetSlide,
animSlide,
oldSlide,
slideLeft,
targetLeft = null,
_ = this,
navTarget
sync = sync || false
if (_.animating === true && _.options.waitForAnimate === true) {
return
}
if (_.options.fade === true && _.currentSlide === index) {
return
}
if (sync === false) {
_.asNavFor(index)
}
targetSlide = index
targetLeft = _.getLeft(targetSlide)
slideLeft = _.getLeft(_.currentSlide)
_.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft
if (
_.options.infinite === false &&
_.options.centerMode === false &&
(index < 0 || index > _.getDotCount() * _.options.slidesToScroll)
) {
if (_.options.fade === false) {
targetSlide = _.currentSlide
if (dontAnimate !== true) {
_.animateSlide(slideLeft, function () {
_.postSlide(targetSlide)
})
} else {
_.postSlide(targetSlide)
}
}
return
} else if (
_.options.infinite === false &&
_.options.centerMode === true &&
(index < 0 || index > _.slideCount - _.options.slidesToScroll)
) {
if (_.options.fade === false) {
targetSlide = _.currentSlide
if (dontAnimate !== true) {
_.animateSlide(slideLeft, function () {
_.postSlide(targetSlide)
})
} else {
_.postSlide(targetSlide)
}
}
return
}
if (_.options.autoplay) {
clearInterval(_.autoPlayTimer)
}
if (targetSlide < 0) {
if (_.slideCount % _.options.slidesToScroll !== 0) {
animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll)
} else {
animSlide = _.slideCount + targetSlide
}
} else if (targetSlide >= _.slideCount) {
if (_.slideCount % _.options.slidesToScroll !== 0) {
animSlide = 0
} else {
animSlide = targetSlide - _.slideCount
}
} else {
animSlide = targetSlide
}
_.animating = true
_.$slider.trigger('beforeChange', [_, _.currentSlide, animSlide])
oldSlide = _.currentSlide
_.currentSlide = animSlide
_.setSlideClasses(_.currentSlide)
if (_.options.asNavFor) {
navTarget = _.getNavTarget()
navTarget = navTarget.slick('getSlick')
if (navTarget.slideCount <= navTarget.options.slidesToShow) {
navTarget.setSlideClasses(_.currentSlide)
}
}
_.updateDots()
_.updateArrows()
if (_.options.fade === true) {
if (dontAnimate !== true) {
_.fadeSlideOut(oldSlide)
_.fadeSlide(animSlide, function () {
_.postSlide(animSlide)
})
} else {
_.postSlide(animSlide)
}
_.animateHeight()
return
}
if (dontAnimate !== true) {
_.animateSlide(targetLeft, function () {
_.postSlide(animSlide)
})
} else {
_.postSlide(animSlide)
}
}
Slick.prototype.startLoad = function () {
var _ = this
if (
_.options.arrows === true &&
_.slideCount > _.options.slidesToShow
) {
_.$prevArrow.hide()
_.$nextArrow.hide()
}
if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
_.$dots.hide()
}
_.$slider.addClass('slick-loading')
}
Slick.prototype.swipeDirection = function () {
var xDist,
yDist,
r,
swipeAngle,
_ = this
xDist = _.touchObject.startX - _.touchObject.curX
yDist = _.touchObject.startY - _.touchObject.curY
r = Math.atan2(yDist, xDist)
swipeAngle = Math.round((r * 180) / Math.PI)
if (swipeAngle < 0) {
swipeAngle = 360 - Math.abs(swipeAngle)
}
if (swipeAngle <= 45 && swipeAngle >= 0) {
return _.options.rtl === false ? 'left' : 'right'
}
if (swipeAngle <= 360 && swipeAngle >= 315) {
return _.options.rtl === false ? 'left' : 'right'
}
if (swipeAngle >= 135 && swipeAngle <= 225) {
return _.options.rtl === false ? 'right' : 'left'
}
if (_.options.verticalSwiping === true) {
if (swipeAngle >= 35 && swipeAngle <= 135) {
return 'down'
} else {
return 'up'
}
}
return 'vertical'
}
Slick.prototype.swipeEnd = function (event) {
var _ = this,
slideCount,
direction
_.dragging = false
_.swiping = false
if (_.scrolling) {
_.scrolling = false
return false
}
_.interrupted = false
_.shouldClick = _.touchObject.swipeLength > 10 ? false : true
if (_.touchObject.curX === undefined) {
return false
}
if (_.touchObject.edgeHit === true) {
_.$slider.trigger('edge', [_, _.swipeDirection()])
}
if (_.touchObject.swipeLength >= _.touchObject.minSwipe) {
direction = _.swipeDirection()
switch (direction) {
case 'left':
case 'down':
slideCount = _.options.swipeToSlide
? _.checkNavigable(_.currentSlide + _.getSlideCount())
: _.currentSlide + _.getSlideCount()
_.currentDirection = 0
break
case 'right':
case 'up':
slideCount = _.options.swipeToSlide
? _.checkNavigable(_.currentSlide - _.getSlideCount())
: _.currentSlide - _.getSlideCount()
_.currentDirection = 1
break
default:
}
if (direction != 'vertical') {
_.slideHandler(slideCount)
_.touchObject = {}
_.$slider.trigger('swipe', [_, direction])
}
} else {
if (_.touchObject.startX !== _.touchObject.curX) {
_.slideHandler(_.currentSlide)
_.touchObject = {}
}
}
}
Slick.prototype.swipeHandler = function (event) {
var _ = this
if (
_.options.swipe === false ||
('ontouchend' in document && _.options.swipe === false)
) {
return
} else if (
_.options.draggable === false &&
event.type.indexOf('mouse') !== -1
) {
return
}
_.touchObject.fingerCount =
event.originalEvent && event.originalEvent.touches !== undefined
? event.originalEvent.touches.length
: 1
_.touchObject.minSwipe = _.listWidth / _.options.touchThreshold
if (_.options.verticalSwiping === true) {
_.touchObject.minSwipe = _.listHeight / _.options.touchThreshold
}
switch (event.data.action) {
case 'start':
_.swipeStart(event)
break
case 'move':
_.swipeMove(event)
break
case 'end':
_.swipeEnd(event)
break
}
}
Slick.prototype.swipeMove = function (event) {
var _ = this,
edgeWasHit = false,
curLeft,
swipeDirection,
swipeLength,
positionOffset,
touches,
verticalSwipeLength
touches =
event.originalEvent !== undefined ? event.originalEvent.touches : null
if (!_.dragging || _.scrolling || (touches && touches.length !== 1)) {
return false
}
curLeft = _.getLeft(_.currentSlide)
_.touchObject.curX =
touches !== undefined ? touches[0].pageX : event.clientX
_.touchObject.curY =
touches !== undefined ? touches[0].pageY : event.clientY
_.touchObject.swipeLength = Math.round(
Math.sqrt(Math.pow(_.touchObject.curX - _.touchObject.startX, 2))
)
verticalSwipeLength = Math.round(
Math.sqrt(Math.pow(_.touchObject.curY - _.touchObject.startY, 2))
)
if (
!_.options.verticalSwiping &&
!_.swiping &&
verticalSwipeLength > 4
) {
_.scrolling = true
return false
}
if (_.options.verticalSwiping === true) {
_.touchObject.swipeLength = verticalSwipeLength
}
swipeDirection = _.swipeDirection()
if (
event.originalEvent !== undefined &&
_.touchObject.swipeLength > 4
) {
_.swiping = true
event.preventDefault()
}
positionOffset =
(_.options.rtl === false ? 1 : -1) *
(_.touchObject.curX > _.touchObject.startX ? 1 : -1)
if (_.options.verticalSwiping === true) {
positionOffset = _.touchObject.curY > _.touchObject.startY ? 1 : -1
}
swipeLength = _.touchObject.swipeLength
_.touchObject.edgeHit = false
if (_.options.infinite === false) {
if (
(_.currentSlide === 0 && swipeDirection === 'right') ||
(_.currentSlide >= _.getDotCount() && swipeDirection === 'left')
) {
swipeLength = _.touchObject.swipeLength * _.options.edgeFriction
_.touchObject.edgeHit = true
}
}
if (_.options.vertical === false) {
_.swipeLeft = curLeft + swipeLength * positionOffset
} else {
_.swipeLeft =
curLeft +
swipeLength * (_.$list.height() / _.listWidth) * positionOffset
}
if (_.options.verticalSwiping === true) {
_.swipeLeft = curLeft + swipeLength * positionOffset
}
if (_.options.fade === true || _.options.touchMove === false) {
return false
}
if (_.animating === true) {
_.swipeLeft = null
return false
}
_.setCSS(_.swipeLeft)
}
Slick.prototype.swipeStart = function (event) {
var _ = this,
touches
_.interrupted = true
if (
_.touchObject.fingerCount !== 1 ||
_.slideCount <= _.options.slidesToShow
) {
_.touchObject = {}
return false
}
if (
event.originalEvent !== undefined &&
event.originalEvent.touches !== undefined
) {
touches = event.originalEvent.touches[0]
}
_.touchObject.startX = _.touchObject.curX =
touches !== undefined ? touches.pageX : event.clientX
_.touchObject.startY = _.touchObject.curY =
touches !== undefined ? touches.pageY : event.clientY
_.dragging = true
}
Slick.prototype.unfilterSlides = Slick.prototype.slickUnfilter =
function () {
var _ = this
if (_.$slidesCache !== null) {
_.unload()
_.$slideTrack.children(this.options.slide).detach()
_.$slidesCache.appendTo(_.$slideTrack)
_.reinit()
}
}
Slick.prototype.unload = function () {
var _ = this
$('.slick-cloned', _.$slider).remove()
if (_.$dots) {
_.$dots.remove()
}
if (_.$prevArrow && _.htmlExpr.test(_.options.prevArrow)) {
_.$prevArrow.remove()
}
if (_.$nextArrow && _.htmlExpr.test(_.options.nextArrow)) {
_.$nextArrow.remove()
}
_.$slides
.removeClass('slick-slide slick-active slick-visible slick-current')
.attr('aria-hidden', 'true')
.css('width', '')
}
Slick.prototype.unslick = function (fromBreakpoint) {
var _ = this
_.$slider.trigger('unslick', [_, fromBreakpoint])
_.destroy()
}
Slick.prototype.updateArrows = function () {
var _ = this,
centerOffset
centerOffset = Math.floor(_.options.slidesToShow / 2)
if (
_.options.arrows === true &&
_.slideCount > _.options.slidesToShow &&
!_.options.infinite
) {
_.$prevArrow
.removeClass('slick-disabled')
.attr('aria-disabled', 'false')
_.$nextArrow
.removeClass('slick-disabled')
.attr('aria-disabled', 'false')
if (_.currentSlide === 0) {
_.$prevArrow
.addClass('slick-disabled')
.attr('aria-disabled', 'true')
_.$nextArrow
.removeClass('slick-disabled')
.attr('aria-disabled', 'false')
} else if (
_.currentSlide >= _.slideCount - _.options.slidesToShow &&
_.options.centerMode === false
) {
_.$nextArrow
.addClass('slick-disabled')
.attr('aria-disabled', 'true')
_.$prevArrow
.removeClass('slick-disabled')
.attr('aria-disabled', 'false')
} else if (
_.currentSlide >= _.slideCount - 1 &&
_.options.centerMode === true
) {
_.$nextArrow
.addClass('slick-disabled')
.attr('aria-disabled', 'true')
_.$prevArrow
.removeClass('slick-disabled')
.attr('aria-disabled', 'false')
}
}
}
Slick.prototype.updateDots = function () {
var _ = this
if (_.$dots !== null) {
_.$dots.find('li').removeClass('slick-active').end()
_.$dots
.find('li')
.eq(Math.floor(_.currentSlide / _.options.slidesToScroll))
.addClass('slick-active')
}
}
Slick.prototype.visibility = function () {
var _ = this
if (_.options.autoplay) {
if (document[_.hidden]) {
_.interrupted = true
} else {
_.interrupted = false
}
}
}
$.fn.slick = function () {
var _ = this,
opt = arguments[0],
args = Array.prototype.slice.call(arguments, 1),
l = _.length,
i,
ret
for (i = 0; i < l; i++) {
if (typeof opt == 'object' || typeof opt == 'undefined')
_[i].slick = new Slick(_[i], opt)
else ret = _[i].slick[opt].apply(_[i].slick, args)
if (typeof ret != 'undefined') return ret
}
return _
}
})
/*setTimeout(function () {
initSlider(selector, options);
}, 250);*/
}
}
//DONGND:: create option for slick slider of modal popup at product page
var options_modal_product_page = {
speed: 300,
dots: false,
infinite: false,
slidesToShow: 4,
slidesToScroll: 1,
vertical: true,
verticalSwiping: true,
responsive: [
{
breakpoint: 1200,
settings: {
slidesToShow: 3,
slidesToScroll: 1,
},
},
{
breakpoint: 992,
settings: {
slidesToShow: 2,
slidesToScroll: 1,
},
},
{
breakpoint: 768,
settings: {
slidesToShow: 2,
slidesToScroll: 1,
},
},
{
breakpoint: 576,
settings: {
slidesToShow: 1,
slidesToScroll: 1,
},
},
{
breakpoint: 480,
settings: {
slidesToShow: 2,
slidesToScroll: 1,
},
},
{
breakpoint: 400,
settings: {
slidesToShow: 1,
slidesToScroll: 1,
},
},
],
}
//DONGND:: create option for slick slider of quickview
var options_quickview = {
speed: 300,
dots: false,
infinite: false,
slidesToShow: 4,
slidesToScroll: 1,
vertical: true,
verticalSwiping: true,
responsive: [
{
breakpoint: 1200,
settings: {
slidesToShow: 4,
slidesToScroll: 1,
},
},
{
breakpoint: 992,
settings: {
slidesToShow: 3,
slidesToScroll: 1,
},
},
{
breakpoint: 768,
settings: {
slidesToShow: 4,
slidesToScroll: 1,
},
},
{
breakpoint: 576,
settings: {
slidesToShow: 3,
slidesToScroll: 1,
},
},
{
breakpoint: 480,
settings: {
slidesToShow: 2,
slidesToScroll: 1,
},
},
],
}
$(window).resize(function () {
//DONGND:: fix zoom, only work at product page
if (prestashop.page.page_name == 'product') restartElevateZoom()
//DONGND:: fix lost slider of modal when resize
if (
$('#product-modal .product-images').hasClass('slick-initialized') &&
$('#product-modal .product-images').height() == 0
) {
//DONGND:: setup slide for product thumb (modal)
$('#product-modal .product-images').slick('unslick')
$('#product-modal .product-images').hide()
initSlickProductModal()
}
})
$(document).ready(function () {
floatHeader()
backtotop()
//check page product only
if (prestashop.page.page_name == 'product') {
innitSlickandZoom()
}
if (prestashop.page.page_name == 'category') {
setDefaultListGrid()
}
if (typeof products_list_functions != 'undefined') {
for (var i = 0; i < products_list_functions.length; i++) {
products_list_functions[i]()
}
}
//DONGND:: update for order page - tab adress, when change adress, block adress change class selected
$('.address-item .radio-block').click(function () {
if (!$(this).parents('.address-item').hasClass('selected')) {
$('.address-item.selected').removeClass('selected')
$(this).parents('.address-item').addClass('selected')
}
})
//DONGND:: loading quickview
actionQuickViewLoading()
prestashop.on('updateProductList', function () {
actionQuickViewLoading()
})
prestashop.on('updatedProduct', function () {
if ($('.quickview.modal .product-thumb-images').length) {
//DONGND:: run slick slider for product thumb - quickview
initSlickProductQuickView()
} else if ($('.product-detail .product-thumb-images').length) {
//DONGND:: re-call setup slick when change attribute at product page
innitSlickandZoom()
}
})
//DONGND:: display modal by config
if (typeof $('#content').data('templatemodal') != 'undefined') {
if (!$('#content').data('templatemodal')) {
$('div[data-target="#product-modal"]').hide()
}
}
//DONGND:: create demo product detail from megamenu
$('.demo-product-detail a').click(function (e) {
if (!$(this).hasClass('updated')) {
e.preventDefault()
var current_url = window.location.href
if (
prestashop.page.page_name == 'product' &&
current_url.indexOf('.html') >= 0
) {
var link_href = $(this).attr('href')
var layout_key_index = link_href.indexOf('?layout=')
var layout_key_value = link_href.substring(layout_key_index)
current_url = current_url.substring(0, current_url.indexOf('.html'))
var new_url = current_url + '.html' + layout_key_value
window.location.href = new_url
}
}
})
})
function innitSlickandZoom() {
if ($('#main').hasClass('product-image-thumbs')) {
/*!
* imagesLoaded v5.0.0
* JavaScript is all like "You images are done yet or what?"
* MIT License
*/
;(function (window, factory) {
// universal module definition
if (typeof module == 'object' && module.exports) {
// CommonJS
module.exports = factory(window, require('ev-emitter'))
} else {
// browser global
window.imagesLoaded = factory(window, window.EvEmitter)
}
})(
typeof window !== 'undefined' ? window : this,
function factory(window, EvEmitter) {
let $ = window.jQuery
let console = window.console
// -------------------------- helpers -------------------------- //
// turn element or nodeList into an array
function makeArray(obj) {
// use object if already an array
if (Array.isArray(obj)) return obj
let isArrayLike =
typeof obj == 'object' && typeof obj.length == 'number'
// convert nodeList to array
if (isArrayLike) return [...obj]
// array of single index
return [obj]
}
// -------------------------- imagesLoaded -------------------------- //
/**
* @param {[Array, Element, NodeList, String]} elem
* @param {[Object, Function]} options - if function, use as callback
* @param {Function} onAlways - callback function
* @returns {ImagesLoaded}
*/
function ImagesLoaded(elem, options, onAlways) {
// coerce ImagesLoaded() without new, to be new ImagesLoaded()
if (!(this instanceof ImagesLoaded)) {
return new ImagesLoaded(elem, options, onAlways)
}
// use elem as selector string
let queryElem = elem
if (typeof elem == 'string') {
queryElem = document.querySelectorAll(elem)
}
// bail if bad element
if (!queryElem) {
console.error(`Bad element for imagesLoaded ${queryElem || elem}`)
return
}
this.elements = makeArray(queryElem)
this.options = {}
// shift arguments if no options set
if (typeof options == 'function') {
onAlways = options
} else {
Object.assign(this.options, options)
}
if (onAlways) this.on('always', onAlways)
this.getImages()
// add jQuery Deferred object
if ($) this.jqDeferred = new $.Deferred()
// HACK check async to allow time to bind listeners
setTimeout(this.check.bind(this))
}
ImagesLoaded.prototype = Object.create(EvEmitter.prototype)
ImagesLoaded.prototype.getImages = function () {
this.images = []
// filter & find items if we have an item selector
this.elements.forEach(this.addElementImages, this)
}
const elementNodeTypes = [1, 9, 11]
/**
* @param {Node} elem
*/
ImagesLoaded.prototype.addElementImages = function (elem) {
// filter siblings
if (elem.nodeName === 'IMG') {
this.addImage(elem)
}
// get background image on element
if (this.options.background === true) {
this.addElementBackgroundImages(elem)
}
// find children
// no non-element nodes, #143
let { nodeType } = elem
if (!nodeType || !elementNodeTypes.includes(nodeType)) return
let childImgs = elem.querySelectorAll('img')
// concat childElems to filterFound array
for (let img of childImgs) {
this.addImage(img)
}
// get child background images
if (typeof this.options.background == 'string') {
let children = elem.querySelectorAll(this.options.background)
for (let child of children) {
this.addElementBackgroundImages(child)
}
}
}
const reURL = /url\((['"])?(.*?)\1\)/gi
ImagesLoaded.prototype.addElementBackgroundImages = function (elem) {
let style = getComputedStyle(elem)
// Firefox returns null if in a hidden iframe https://bugzil.la/548397
if (!style) return
// get url inside url("...")
let matches = reURL.exec(style.backgroundImage)
while (matches !== null) {
let url = matches && matches[2]
if (url) {
this.addBackground(url, elem)
}
matches = reURL.exec(style.backgroundImage)
}
}
/**
* @param {Image} img
*/
ImagesLoaded.prototype.addImage = function (img) {
let loadingImage = new LoadingImage(img)
this.images.push(loadingImage)
}
ImagesLoaded.prototype.addBackground = function (url, elem) {
let background = new Background(url, elem)
this.images.push(background)
}
ImagesLoaded.prototype.check = function () {
this.progressedCount = 0
this.hasAnyBroken = false
// complete if no images
if (!this.images.length) {
this.complete()
return
}
/* eslint-disable-next-line func-style */
let onProgress = (image, elem, message) => {
// HACK - Chrome triggers event before object properties have changed. #83
setTimeout(() => {
this.progress(image, elem, message)
})
}
this.images.forEach(function (loadingImage) {
loadingImage.once('progress', onProgress)
loadingImage.check()
})
}
ImagesLoaded.prototype.progress = function (image, elem, message) {
this.progressedCount++
this.hasAnyBroken = this.hasAnyBroken || !image.isLoaded
// progress event
this.emitEvent('progress', [this, image, elem])
if (this.jqDeferred && this.jqDeferred.notify) {
this.jqDeferred.notify(this, image)
}
// check if completed
if (this.progressedCount === this.images.length) {
this.complete()
}
if (this.options.debug && console) {
console.log(`progress: ${message}`, image, elem)
}
}
ImagesLoaded.prototype.complete = function () {
let eventName = this.hasAnyBroken ? 'fail' : 'done'
this.isComplete = true
this.emitEvent(eventName, [this])
this.emitEvent('always', [this])
if (this.jqDeferred) {
let jqMethod = this.hasAnyBroken ? 'reject' : 'resolve'
this.jqDeferred[jqMethod](this)
}
}
// -------------------------- -------------------------- //
function LoadingImage(img) {
this.img = img
}
LoadingImage.prototype = Object.create(EvEmitter.prototype)
LoadingImage.prototype.check = function () {
// If complete is true and browser supports natural sizes,
// try to check for image status manually.
let isComplete = this.getIsImageComplete()
if (isComplete) {
// report based on naturalWidth
this.confirm(this.img.naturalWidth !== 0, 'naturalWidth')
return
}
// If none of the checks above matched, simulate loading on detached element.
this.proxyImage = new Image()
// add crossOrigin attribute. #204
if (this.img.crossOrigin) {
this.proxyImage.crossOrigin = this.img.crossOrigin
}
this.proxyImage.addEventListener('load', this)
this.proxyImage.addEventListener('error', this)
// bind to image as well for Firefox. #191
this.img.addEventListener('load', this)
this.img.addEventListener('error', this)
this.proxyImage.src = this.img.currentSrc || this.img.src
}
LoadingImage.prototype.getIsImageComplete = function () {
// check for non-zero, non-undefined naturalWidth
// fixes Safari+InfiniteScroll+Masonry bug infinite-scroll#671
return this.img.complete && this.img.naturalWidth
}
LoadingImage.prototype.confirm = function (isLoaded, message) {
this.isLoaded = isLoaded
let { parentNode } = this.img
// emit progress with parent <picture> or self <img>
let elem = parentNode.nodeName === 'PICTURE' ? parentNode : this.img
this.emitEvent('progress', [this, elem, message])
}
// ----- events ----- //
// trigger specified handler for event type
LoadingImage.prototype.handleEvent = function (event) {
let method = 'on' + event.type
if (this[method]) {
this[method](event)
}
}
LoadingImage.prototype.onload = function () {
this.confirm(true, 'onload')
this.unbindEvents()
}
LoadingImage.prototype.onerror = function () {
this.confirm(false, 'onerror')
this.unbindEvents()
}
LoadingImage.prototype.unbindEvents = function () {
this.proxyImage.removeEventListener('load', this)
this.proxyImage.removeEventListener('error', this)
this.img.removeEventListener('load', this)
this.img.removeEventListener('error', this)
}
// -------------------------- Background -------------------------- //
function Background(url, element) {
this.url = url
this.element = element
this.img = new Image()
}
// inherit LoadingImage prototype
Background.prototype = Object.create(LoadingImage.prototype)
Background.prototype.check = function () {
this.img.addEventListener('load', this)
this.img.addEventListener('error', this)
this.img.src = this.url
// check if image is already complete
let isComplete = this.getIsImageComplete()
if (isComplete) {
this.confirm(this.img.naturalWidth !== 0, 'naturalWidth')
this.unbindEvents()
}
}
Background.prototype.unbindEvents = function () {
this.img.removeEventListener('load', this)
this.img.removeEventListener('error', this)
}
Background.prototype.confirm = function (isLoaded, message) {
this.isLoaded = isLoaded
this.emitEvent('progress', [this, this.element, message])
}
// -------------------------- jQuery -------------------------- //
ImagesLoaded.makeJQueryPlugin = function (jQuery) {
jQuery = jQuery || window.jQuery
if (!jQuery) return
// set local variable
$ = jQuery
// $().imagesLoaded()
$.fn.imagesLoaded = function (options, onAlways) {
let instance = new ImagesLoaded(this, options, onAlways)
return instance.jqDeferred.promise($(this))
}
}
// try making plugin
ImagesLoaded.makeJQueryPlugin()
// -------------------------- -------------------------- //
return ImagesLoaded
}
)
//DONGND:: setup slide for product thumb (main)
$('.product-detail .product-thumb-images').imagesLoaded(function () {
if (typeof check_loaded_main_product != 'undefined') {
clearInterval(check_loaded_main_product)
}
check_loaded_main_product = setInterval(function () {
if ($('.product-detail .product-thumb-images').height() > 0) {
$('.product-detail .product-thumb-images').fadeIn()
clearInterval(check_loaded_main_product)
postion = $('#content').data('templateview')
//DONGND:: add config for over 1200 extra large
numberimage = $('#content').data('numberimage')
numberimage1200 = $('#content').data('numberimage1200')
numberimage992 = $('#content').data('numberimage992')
numberimage768 = $('#content').data('numberimage768')
numberimage576 = $('#content').data('numberimage576')
numberimage480 = $('#content').data('numberimage480')
numberimage360 = $('#content').data('numberimage360')
if (postion !== 'undefined') {
initSlickProductThumb(
postion,
numberimage,
numberimage1200,
numberimage992,
numberimage768,
numberimage576,
numberimage480,
numberimage360
)
}
}
}, 300)
})
//DONGND:: setup slide for product thumb (modal)
initSlickProductModal()
}
//call action zoom
restartElevateZoom()
}
function restartElevateZoom() {
$('.zoomContainer').remove()
applyElevateZoom()
}
function applyElevateZoom() {
if (
$(window).width() <= 991 ||
$('#content').data('templatezoomtype') == 'none'
) {
//DONGND:: remove elevateZoom on mobile
if ($('#main').hasClass('product-image-gallery')) {
if ($('img.js-thumb').data('elevateZoom')) {
var ezApi = $('img.js-thumb').data('elevateZoom')
ezApi.changeState('disable')
$('img.js-thumb').unbind('touchmove')
}
} else {
if ($('#zoom_product').data('elevateZoom')) {
var ezApi = $('#zoom_product').data('elevateZoom')
ezApi.changeState('disable')
$('#zoom_product').unbind('touchmove')
}
}
return false
}
//check if that is gallery, zoom all thumb
//DONGND:: fix zoom, create config
var zt = $('#content').data('templatezoomtype')
var zoom_cursor
var zoom_type
var scroll_zoom = false
var lens_FadeIn = 200
var lens_FadeOut = 200
var zoomWindow_FadeIn = 200
var zoomWindow_FadeOut = 200
var zoom_tint = false
var zoomWindow_Width = 400
var zoomWindow_Height = 400
var zoomWindow_Position = 1
if (zt == 'in') {
zoom_cursor = 'crosshair'
zoom_type = 'inner'
lens_FadeIn = false
lens_FadeOut = false
} else {
zoom_cursor = 'default'
zoom_type = 'window'
zoom_tint = true
zoomWindow_Width = $('#content').data('zoomwindowwidth')
zoomWindow_Height = $('#content').data('zoomwindowheight')
if ($('#content').data('zoomposition') == 'right') {
//DONGND:: update position of zoom window with ar language
if (prestashop.language.is_rtl == 1) {
zoomWindow_Position = 11
} else {
zoomWindow_Position = 1
}
}
if ($('#content').data('zoomposition') == 'left') {
//DONGND:: update position of zoom window with ar language
if (prestashop.language.is_rtl == 1) {
zoomWindow_Position = 1
} else {
zoomWindow_Position = 11
}
}
if ($('#content').data('zoomposition') == 'top') {
zoomWindow_Position = 13
}
if ($('#content').data('zoomposition') == 'bottom') {
zoomWindow_Position = 7
}
if (zt == 'in_scrooll') {
//DONGND:: scroll to zoom does not work on IE
var ua = window.navigator.userAgent
var old_ie = ua.indexOf('MSIE ')
var new_ie = ua.indexOf('Trident/')
if (old_ie > 0 || new_ie > 0) {
// If Internet Explorer, return version number
scroll_zoom = false
} // If another browser, return 0
else {
scroll_zoom = true
}
}
}
if ($('#main').hasClass('product-image-gallery')) {
lens_FadeIn = false
lens_FadeOut = false
zoomWindow_FadeIn = false
zoomWindow_FadeOut = false
}
var zoom_config = {
responsive: true,
cursor: zoom_cursor,
scrollZoom: scroll_zoom,
scrollZoomIncrement: 0.1,
zoomLevel: 1,
zoomType: zoom_type,
gallery: 'thumb-gallery',
lensFadeIn: lens_FadeIn,
lensFadeOut: lens_FadeOut,
zoomWindowFadeIn: zoomWindow_FadeIn,
zoomWindowFadeOut: zoomWindow_FadeOut,
zoomWindowWidth: zoomWindow_Width,
zoomWindowHeight: zoomWindow_Height,
borderColour: '#888',
borderSize: 2,
zoomWindowOffetx: 0,
zoomWindowOffety: 0,
zoomWindowPosition: zoomWindow_Position,
tint: zoom_tint,
}
if ($('#main').hasClass('product-image-gallery')) {
$('img.js-thumb').each(function () {
var parent_e = $(this).parent()
$(this).attr('src', parent_e.data('image'))
$(this).data('type-zoom', parent_e.data('zoom-image'))
})
if ($.fn.elevateZoom !== undefined) {
$('img.js-thumb').elevateZoom(zoom_config)
//DONGND:: fix click a thumb replace all image and add fancybox
$('img.js-thumb').bind('click', function (e) {
var ez = $(this).data('elevateZoom')
$.fancybox(ez.getGalleryList())
return false
})
}
} else {
if ($.fn.elevateZoom !== undefined) {
$('#zoom_product').elevateZoom(zoom_config)
//pass the images to Fancybox
$('#zoom_product').bind('click', function (e) {
var ez = $('#zoom_product').data('elevateZoom')
$.fancybox(ez.getGalleryList())
return false
})
}
}
}
function initSlickProductThumb(
postion,
numberimage,
numberimage1200,
numberimage992,
numberimage768,
numberimage576,
numberimage480,
numberimage360
) {
var vertical = true
var verticalSwiping = true
//DONGND:: update for rtl
var slick_rtl = false
if (postion == 'bottom') {
vertical = false
verticalSwiping = false
}
if (postion == 'none') {
vertical = false
verticalSwiping = false
numberimage =
numberimage1200 =
numberimage992 =
numberimage768 =
numberimage576 =
numberimage480 =
numberimage360 =
1
}
//DONGND:: update for rtl
if (!vertical && prestashop.language.is_rtl == 1) {
slick_rtl = true
}
initSlider('#thumb-gallery', {
speed: 300,
dots: false,
infinite: false,
slidesToShow: numberimage,
vertical: vertical,
verticalSwiping: verticalSwiping,
slidesToScroll: 1,
rtl: slick_rtl,
responsive: [
{
breakpoint: 1200,
settings: {
slidesToShow: numberimage1200,
slidesToScroll: 1,
},
},
{
breakpoint: 992,
settings: {
slidesToShow: numberimage992,
slidesToScroll: 1,
},
},
{
breakpoint: 768,
settings: {
slidesToShow: numberimage768,
slidesToScroll: 1,
},
},
{
breakpoint: 576,
settings: {
slidesToShow: numberimage576,
slidesToScroll: 1,
},
},
{
breakpoint: 480,
settings: {
slidesToShow: numberimage480,
slidesToScroll: 1,
},
},
{
breakpoint: 360,
settings: {
slidesToShow: numberimage360,
slidesToScroll: 1,
},
},
],
})
$('#thumb-gallery').show()
if (postion == 'none') {
var slickInstance = slider[0]
var slides = $(slickInstance.slick.$slides)
var positionStart = findPosition(slides)
var slideCount = slickInstance.slick.slideCount
//DONGND:: update slick for case without thubms
if (positionStart + 1 == slideCount) {
$('.arrows-product-fake .slick-next').addClass('slick-disabled')
} else if (positionStart == 0) {
$('.arrows-product-fake .slick-prev').addClass('slick-disabled')
}
// active image first load
slider.slick('slickGoTo', positionStart)
$('.arrows-product-fake .slick-next').on('click', function () {
if (!$(this).hasClass('slick-disabled')) {
$('.arrows-product-fake .slick-prev').removeClass('slick-disabled')
var positionCurrent = findPosition(slides)
if (positionCurrent + 1 < slideCount) {
$(slides[positionCurrent]).removeClass('active')
$(slides[positionCurrent + 1]).addClass('active')
$(slides[positionCurrent + 1])
.find('img')
.trigger('click')
slider.slick('slickNext')
if (positionCurrent + 1 == slideCount - 1) {
$(this).addClass('slick-disabled')
}
}
}
})
$('.arrows-product-fake .slick-prev').on('click', function () {
if (!$(this).hasClass('slick-disabled')) {
$('.arrows-product-fake .slick-next').removeClass('slick-disabled')
var positionCurrent = findPosition(slides)
if (positionCurrent > 0) {
$(slides[positionCurrent]).removeClass('active')
$(slides[positionCurrent - 1]).addClass('active')
$(slides[positionCurrent - 1])
.find('img')
.trigger('click')
slider.slick('slickPrev')
if (positionCurrent - 1 == 0) {
$(this).addClass('slick-disabled')
}
}
}
})
}
}
function findPosition(slides) {
var position
for (var i = 0; i < slides.length; i++) {
if ($(slides[i]).hasClass('active')) {
position = $(slides[i]).data('slick-index')
return position
}
}
}
//DONGND:: loading quickview
function actionQuickViewLoading() {
$('.quick-view').click(function () {
if (!$(this).hasClass('active')) {
$(this).addClass('active')
$(this).find('.leo-quickview-bt-loading').css({
display: 'block',
})
$(this).find('.leo-quickview-bt-content').hide()
if (typeof check_active_quickview != 'undefined') {
clearInterval(check_active_quickview)
}
check_active_quickview = setInterval(function () {
if ($('.quickview.modal').length) {
$('.quickview.modal').on('hide.bs.modal', function (e) {
$('.quick-view.active').find('.leo-quickview-bt-loading').hide()
$('.quick-view.active').find('.leo-quickview-bt-content').show()
$('.quick-view.active').removeClass('active')
})
clearInterval(check_active_quickview)
//DONGND:: run slick for product thumb - quickview
initSlickProductQuickView()
}
}, 300)
}
})
}
$(document).on('click', '.leo_grid', function (e) {
e.preventDefault()
$('#js-product-list .product_list').removeClass('list')
$('#js-product-list .product_list').addClass('grid')
$(this).parent().find('.leo_list').removeClass('selected')
$(this).addClass('selected')
var configName = LEO_COOKIE_THEME + '_grid_list'
$.cookie(configName, 'grid', {
expires: 1,
path: '/',
})
})
$(document).on('click', '.leo_list', function (e) {
e.preventDefault()
$('#js-product-list .product_list').removeClass('grid')
$('#js-product-list .product_list').addClass('list')
$(this).parent().find('.leo_grid').removeClass('selected')
$(this).addClass('selected')
var configName = LEO_COOKIE_THEME + '_grid_list'
$.cookie(configName, 'list', {
expires: 1,
path: '/',
})
})
function setDefaultListGrid() {
if ($.cookie(LEO_COOKIE_THEME + '_grid_list') == 'grid') {
$('.leo_grid').trigger('click')
}
if ($.cookie(LEO_COOKIE_THEME + '_grid_list') == 'list') {
$('.leo_list').trigger('click')
}
}
function processFloatHeader(headerAdd, scroolAction) {
//DONGND:: hide search result when enable float header
if ($('.ac_results').length) {
$('.ac_results').hide()
}
if (headerAdd) {
$('#header').addClass('navbar-fixed-top')
var hideheight = $('#header').height() + 120
$('#page').css('padding-top', $('#header').height())
setTimeout(function () {
$('#page').css('padding-top', $('#header').height())
}, 200)
} else {
$('#header').removeClass('navbar-fixed-top')
$('#page').css('padding-top', '')
}
var pos = $(window).scrollTop()
if (scroolAction && pos >= hideheight) {
$('.header-nav').addClass('hide-bar')
$('.hide-bar').css('margin-top', -$('.header-nav').height())
$('#header').addClass('mini-navbar')
} else {
$('.header-nav').removeClass('hide-bar')
$('.header-nav').css('margin-top', 0)
$('#header').removeClass('mini-navbar')
}
}
//Float Menu
function floatHeader() {
if (!$('body').hasClass('keep-header') || $(window).width() <= 990) {
return
}
$(window).resize(function () {
if ($(window).width() <= 990) {
processFloatHeader(0, 0)
} else if ($(window).width() > 990) {
if ($('body').hasClass('keep-header')) processFloatHeader(1, 1)
}
})
var headerScrollTimer
$(window).scroll(function () {
if (headerScrollTimer) {
window.clearTimeout(headerScrollTimer)
}
headerScrollTimer = window.setTimeout(function () {
if (!$('body').hasClass('keep-header')) return
if ($(window).width() > 990) {
processFloatHeader(1, 1)
}
}, 100)
})
}
// Back to top
function backtotop() {
$('#back-top').hide()
$(window).scroll(function () {
if ($(this).scrollTop() > 100) {
$('#back-top').fadeIn()
} else {
$('#back-top').fadeOut()
}
})
// scroll body to 0px on click
$('#back-top a').click(function () {
$('body,html').animate(
{
scrollTop: 0,
},
800
)
return false
})
}
//DONGND:: build slick slider for quickview
function initSlickProductQuickView() {
$('.quickview.modal .product-thumb-images').imagesLoaded(function () {
if (typeof check_loaded_thumb_quickview != 'undefined') {
clearInterval(check_loaded_thumb_quickview)
}
check_loaded_thumb_quickview = setInterval(function () {
if ($('.quickview.modal .product-thumb-images').height() > 0) {
$('.quickview.modal .product-thumb-images').fadeIn()
clearInterval(check_loaded_thumb_quickview)
$('.quickview.modal .product-thumb-images').slick(options_quickview)
}
}, 300)
})
}
//DONGND:: build slick slider for modal - product page
function initSlickProductModal() {
$('#product-modal .product-images').imagesLoaded(function () {
if (typeof check_loaded_thumb_modal != 'undefined') {
clearInterval(check_loaded_thumb_modal)
}
check_loaded_thumb_modal = setInterval(function () {
if ($('#product-modal .product-images').height() > 0) {
$('#product-modal .product-images').fadeIn()
clearInterval(check_loaded_thumb_modal)
$('#product-modal .product-images').slick(options_modal_product_page)
}
}, 300)
})
}
//DONGND: fix base prestashop
$(document).ready(function () {
//DONGND: remove css inline of label
$('.product-flag').removeAttr('style')
prestashop.on('updateProductList', function () {
//DONGND: remove css inline of label
$('.product-flag').removeAttr('style')
})
})
//Fix translate button choose file to upload: change "Choose file" to choosefile_text
//Fix filter (category page) does not work on IE change dataset.searchUrl to getAttribute('data-search-url')
$().ready(function () {
$('#leo_search_block_top .title_block').click(function () {
$(this).parent().toggleClass('active')
setTimeout(function () {
jQuery('#leo_search_block_top.active input.form-control').focus()
}, 100)
})
$(document).keydown(function (e) {
// ESCAPE key pressed
if (e.keyCode == 27) {
$('#leo_search_block_top').removeClass('active')
}
})
$(document).click(function (event) {
if (!$(event.target).closest('#leo_search_block_top').length) {
$('#leo_search_block_top').removeClass('active')
}
})
/*
// fix bug module Amazzingfilter
if ($('body#category').hasClass("page-category")){
customThemeActions.updateContentAfter = function (jsonData) {
if (typeof $.LeoCustomAjax == 'function') {
var leoCustomAjax = new $.LeoCustomAjax();
leoCustomAjax.processAjax();
}
if ($('.af_pl_wrapper').find('.product_list').hasClass('list')) {
$('.leo_list').addClass('selected').siblings().removeClass('selected');
}
}
$( document ).ajaxComplete(function() {
actionQuickViewLoading();
leoBtCart();
LeoWishlistButtonAction();
});
}
*/
$(document).on('ready', function () {
initSlider($('.list-images-mobile'), {
slidesToShow: 1,
slidesToScroll: 1,
arrows: true,
dots: true,
infinite: true,
customPaging: function (slick, index) {
var targetImage = slick.$slides.eq(index).find('img').attr('src')
return '<span><img src=" ' + targetImage + ' "/></span>'
},
})
})
$(document).ajaxComplete(function (event, xhr, settings) {
if (settings.url.indexOf('controller=product') > 0) {
$('.list-images-mobile').slick({
slidesToShow: 1,
slidesToScroll: 1,
arrows: true,
dots: true,
infinite: true,
//centerMode: true,
//fade: true,
customPaging: function (slick, index) {
var targetImage = slick.$slides.eq(index).find('img').attr('src')
return '<span><img src=" ' + targetImage + ' "/></span>'
},
})
}
})
customSticky()
$(document).ajaxComplete(function () {
$('.p-reference .product-reference').html(
$('#product-details .product-reference').clone()
)
$('.p-reference .product-quantities').html(
$('#product-details .product-quantities').clone()
)
})
})
function customSticky() {
if ($('body').attr('id') == 'index') var s = $('.header-top > .inner')
else var s = $('.topnav .wrapper')
var pos = s.offset()
var alreadySticky = false
$(window).scroll(function () {
var windowpos = $(window).scrollTop()
if (s.length) {
if (!alreadySticky) {
if (windowpos > pos.top) {
alreadySticky = true
s.parent().height(s.height())
s.removeClass('cus-nosticky')
s.addClass('cus-sticky')
$('body').removeClass('body-nosticky')
$('body').addClass('body-sticky')
}
}
if (alreadySticky) {
if (windowpos <= pos.top) {
alreadySticky = false
s.removeClass('cus-sticky')
s.addClass('cus-nosticky')
s.parent().removeAttr('style')
$('body').addClass('body-nosticky')
$('body').removeClass('body-sticky')
}
}
}
})
}
$(function () {
function initSizeChartButton() {
var sizeTabLink = $('.product-tabs .nav-link[href="#extra-0"]');
if (!sizeTabLink.length) return;
if ($('.product-size-tab').length) return;
var lang = window.location.pathname.split('/')[1];
var buttonText = lang === 'pl'
? 'TABELA ROZMIARÓW'
: 'SIZE CHART';
var sizeTableBtn = $(
'<a href="#" class="btn btn-outline-secondary mb-1 product-size-tab" style="display:block;">' +
buttonText +
'</a>'
);
var $rozmiarVariant = $('.product-variants .product-variants-item[data-variant="rozmiar"]');
if ($rozmiarVariant.length) {
$rozmiarVariant.addClass('set-size-chart');
$rozmiarVariant.after(sizeTableBtn);
}
sizeTableBtn.on('click', function (e) {
e.preventDefault();
sizeTabLink.tab('show');
var tabsOffset = $('.product-tabs').offset().top;
$('html, body').animate({ scrollTop: tabsOffset - 100 }, 600);
});
}
initSizeChartButton();
if (typeof prestashop !== 'undefined') {
prestashop.on('updatedProduct', function () {
setTimeout(initSizeChartButton, 100);
});
}
});
Reference in New Issue View Git Blame Copy Permalink