source: public/vendors/slick/slick.js@ 11499b3

develop
Last change on this file since 11499b3 was 7304c7f, checked in by beratkjufliju <kufliju@…>, 3 years ago

added user authentication, create & forgot password methods and blades
  • Property mode set to 100644
File size: 86.9 KB
RevLine 
[7304c7f]1/*
2 _ _ _ _
3 ___| (_) ___| | __ (_)___
4/ __| | |/ __| |/ / | / __|
5\__ \ | | (__| < _ | \__ \
6|___/_|_|\___|_|\_(_)/ |___/
7 |__/
8
9 Version: 1.8.0
10 Author: Ken Wheeler
11 Website: http://kenwheeler.github.io
12 Docs: http://kenwheeler.github.io/slick
13 Repo: http://github.com/kenwheeler/slick
14 Issues: http://github.com/kenwheeler/slick/issues
15
16 */
17/* global window, document, define, jQuery, setInterval, clearInterval */
18;(function(factory) {
19 'use strict';
20 if (typeof define === 'function' && define.amd) {
21 define(['jquery'], factory);
22 } else if (typeof exports !== 'undefined') {
23 module.exports = factory(require('jquery'));
24 } else {
25 factory(jQuery);
26 }
27
28}(function($) {
29 'use strict';
30 var Slick = window.Slick || {};
31
32 Slick = (function() {
33
34 var instanceUid = 0;
35
36 function Slick(element, settings) {
37
38 var _ = this, dataSettings;
39
40 _.defaults = {
41 accessibility: true,
42 adaptiveHeight: false,
43 appendArrows: $(element),
44 appendDots: $(element),
45 arrows: true,
46 asNavFor: null,
47 prevArrow: '<button class="slick-prev" aria-label="Previous" type="button">Previous</button>',
48 nextArrow: '<button class="slick-next" aria-label="Next" type="button">Next</button>',
49 autoplay: false,
50 autoplaySpeed: 3000,
51 centerMode: false,
52 centerPadding: '50px',
53 cssEase: 'ease',
54 customPaging: function(slider, i) {
55 return $('<button type="button" />').text(i + 1);
56 },
57 dots: false,
58 dotsClass: 'slick-dots',
59 draggable: true,
60 easing: 'linear',
61 edgeFriction: 0.35,
62 fade: false,
63 focusOnSelect: false,
64 focusOnChange: false,
65 infinite: true,
66 initialSlide: 0,
67 lazyLoad: 'ondemand',
68 mobileFirst: false,
69 pauseOnHover: true,
70 pauseOnFocus: true,
71 pauseOnDotsHover: false,
72 respondTo: 'window',
73 responsive: null,
74 rows: 1,
75 rtl: false,
76 slide: '',
77 slidesPerRow: 1,
78 slidesToShow: 1,
79 slidesToScroll: 1,
80 speed: 500,
81 swipe: true,
82 swipeToSlide: false,
83 touchMove: true,
84 touchThreshold: 5,
85 useCSS: true,
86 useTransform: true,
87 variableWidth: false,
88 vertical: false,
89 verticalSwiping: false,
90 waitForAnimate: true,
91 zIndex: 1000
92 };
93
94 _.initials = {
95 animating: false,
96 dragging: false,
97 autoPlayTimer: null,
98 currentDirection: 0,
99 currentLeft: null,
100 currentSlide: 0,
101 direction: 1,
102 $dots: null,
103 listWidth: null,
104 listHeight: null,
105 loadIndex: 0,
106 $nextArrow: null,
107 $prevArrow: null,
108 scrolling: false,
109 slideCount: null,
110 slideWidth: null,
111 $slideTrack: null,
112 $slides: null,
113 sliding: false,
114 slideOffset: 0,
115 swipeLeft: null,
116 swiping: false,
117 $list: null,
118 touchObject: {},
119 transformsEnabled: false,
120 unslicked: false
121 };
122
123 $.extend(_, _.initials);
124
125 _.activeBreakpoint = null;
126 _.animType = null;
127 _.animProp = null;
128 _.breakpoints = [];
129 _.breakpointSettings = [];
130 _.cssTransitions = false;
131 _.focussed = false;
132 _.interrupted = false;
133 _.hidden = 'hidden';
134 _.paused = true;
135 _.positionProp = null;
136 _.respondTo = null;
137 _.rowCount = 1;
138 _.shouldClick = true;
139 _.$slider = $(element);
140 _.$slidesCache = null;
141 _.transformType = null;
142 _.transitionType = null;
143 _.visibilityChange = 'visibilitychange';
144 _.windowWidth = 0;
145 _.windowTimer = null;
146
147 dataSettings = $(element).data('slick') || {};
148
149 _.options = $.extend({}, _.defaults, settings, dataSettings);
150
151 _.currentSlide = _.options.initialSlide;
152
153 _.originalSettings = _.options;
154
155 if (typeof document.mozHidden !== 'undefined') {
156 _.hidden = 'mozHidden';
157 _.visibilityChange = 'mozvisibilitychange';
158 } else if (typeof document.webkitHidden !== 'undefined') {
159 _.hidden = 'webkitHidden';
160 _.visibilityChange = 'webkitvisibilitychange';
161 }
162
163 _.autoPlay = $.proxy(_.autoPlay, _);
164 _.autoPlayClear = $.proxy(_.autoPlayClear, _);
165 _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);
166 _.changeSlide = $.proxy(_.changeSlide, _);
167 _.clickHandler = $.proxy(_.clickHandler, _);
168 _.selectHandler = $.proxy(_.selectHandler, _);
169 _.setPosition = $.proxy(_.setPosition, _);
170 _.swipeHandler = $.proxy(_.swipeHandler, _);
171 _.dragHandler = $.proxy(_.dragHandler, _);
172 _.keyHandler = $.proxy(_.keyHandler, _);
173
174 _.instanceUid = instanceUid++;
175
176 // A simple way to check for HTML strings
177 // Strict HTML recognition (must start with <)
178 // Extracted from jQuery v1.11 source
179 _.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/;
180
181
182 _.registerBreakpoints();
183 _.init(true);
184
185 }
186
187 return Slick;
188
189 }());
190
191 Slick.prototype.activateADA = function() {
192 var _ = this;
193
194 _.$slideTrack.find('.slick-active').attr({
195 'aria-hidden': 'false'
196 }).find('a, input, button, select').attr({
197 'tabindex': '0'
198 });
199
200 };
201
202 Slick.prototype.addSlide = Slick.prototype.slickAdd = function(markup, index, addBefore) {
203
204 var _ = this;
205
206 if (typeof(index) === 'boolean') {
207 addBefore = index;
208 index = null;
209 } else if (index < 0 || (index >= _.slideCount)) {
210 return false;
211 }
212
213 _.unload();
214
215 if (typeof(index) === 'number') {
216 if (index === 0 && _.$slides.length === 0) {
217 $(markup).appendTo(_.$slideTrack);
218 } else if (addBefore) {
219 $(markup).insertBefore(_.$slides.eq(index));
220 } else {
221 $(markup).insertAfter(_.$slides.eq(index));
222 }
223 } else {
224 if (addBefore === true) {
225 $(markup).prependTo(_.$slideTrack);
226 } else {
227 $(markup).appendTo(_.$slideTrack);
228 }
229 }
230
231 _.$slides = _.$slideTrack.children(this.options.slide);
232
233 _.$slideTrack.children(this.options.slide).detach();
234
235 _.$slideTrack.append(_.$slides);
236
237 _.$slides.each(function(index, element) {
238 $(element).attr('data-slick-index', index);
239 });
240
241 _.$slidesCache = _.$slides;
242
243 _.reinit();
244
245 };
246
247 Slick.prototype.animateHeight = function() {
248 var _ = this;
249 if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
250 var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
251 _.$list.animate({
252 height: targetHeight
253 }, _.options.speed);
254 }
255 };
256
257 Slick.prototype.animateSlide = function(targetLeft, callback) {
258
259 var animProps = {},
260 _ = this;
261
262 _.animateHeight();
263
264 if (_.options.rtl === true && _.options.vertical === false) {
265 targetLeft = -targetLeft;
266 }
267 if (_.transformsEnabled === false) {
268 if (_.options.vertical === false) {
269 _.$slideTrack.animate({
270 left: targetLeft
271 }, _.options.speed, _.options.easing, callback);
272 } else {
273 _.$slideTrack.animate({
274 top: targetLeft
275 }, _.options.speed, _.options.easing, callback);
276 }
277
278 } else {
279
280 if (_.cssTransitions === false) {
281 if (_.options.rtl === true) {
282 _.currentLeft = -(_.currentLeft);
283 }
284 $({
285 animStart: _.currentLeft
286 }).animate({
287 animStart: targetLeft
288 }, {
289 duration: _.options.speed,
290 easing: _.options.easing,
291 step: function(now) {
292 now = Math.ceil(now);
293 if (_.options.vertical === false) {
294 animProps[_.animType] = 'translate(' +
295 now + 'px, 0px)';
296 _.$slideTrack.css(animProps);
297 } else {
298 animProps[_.animType] = 'translate(0px,' +
299 now + 'px)';
300 _.$slideTrack.css(animProps);
301 }
302 },
303 complete: function() {
304 if (callback) {
305 callback.call();
306 }
307 }
308 });
309
310 } else {
311
312 _.applyTransition();
313 targetLeft = Math.ceil(targetLeft);
314
315 if (_.options.vertical === false) {
316 animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';
317 } else {
318 animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';
319 }
320 _.$slideTrack.css(animProps);
321
322 if (callback) {
323 setTimeout(function() {
324
325 _.disableTransition();
326
327 callback.call();
328 }, _.options.speed);
329 }
330
331 }
332
333 }
334
335 };
336
337 Slick.prototype.getNavTarget = function() {
338
339 var _ = this,
340 asNavFor = _.options.asNavFor;
341
342 if ( asNavFor && asNavFor !== null ) {
343 asNavFor = $(asNavFor).not(_.$slider);
344 }
345
346 return asNavFor;
347
348 };
349
350 Slick.prototype.asNavFor = function(index) {
351
352 var _ = this,
353 asNavFor = _.getNavTarget();
354
355 if ( asNavFor !== null && typeof asNavFor === 'object' ) {
356 asNavFor.each(function() {
357 var target = $(this).slick('getSlick');
358 if(!target.unslicked) {
359 target.slideHandler(index, true);
360 }
361 });
362 }
363
364 };
365
366 Slick.prototype.applyTransition = function(slide) {
367
368 var _ = this,
369 transition = {};
370
371 if (_.options.fade === false) {
372 transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;
373 } else {
374 transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
375 }
376
377 if (_.options.fade === false) {
378 _.$slideTrack.css(transition);
379 } else {
380 _.$slides.eq(slide).css(transition);
381 }
382
383 };
384
385 Slick.prototype.autoPlay = function() {
386
387 var _ = this;
388
389 _.autoPlayClear();
390
391 if ( _.slideCount > _.options.slidesToShow ) {
392 _.autoPlayTimer = setInterval( _.autoPlayIterator, _.options.autoplaySpeed );
393 }
394
395 };
396
397 Slick.prototype.autoPlayClear = function() {
398
399 var _ = this;
400
401 if (_.autoPlayTimer) {
402 clearInterval(_.autoPlayTimer);
403 }
404
405 };
406
407 Slick.prototype.autoPlayIterator = function() {
408
409 var _ = this,
410 slideTo = _.currentSlide + _.options.slidesToScroll;
411
412 if ( !_.paused && !_.interrupted && !_.focussed ) {
413
414 if ( _.options.infinite === false ) {
415
416 if ( _.direction === 1 && ( _.currentSlide + 1 ) === ( _.slideCount - 1 )) {
417 _.direction = 0;
418 }
419
420 else if ( _.direction === 0 ) {
421
422 slideTo = _.currentSlide - _.options.slidesToScroll;
423
424 if ( _.currentSlide - 1 === 0 ) {
425 _.direction = 1;
426 }
427
428 }
429
430 }
431
432 _.slideHandler( slideTo );
433
434 }
435
436 };
437
438 Slick.prototype.buildArrows = function() {
439
440 var _ = this;
441
442 if (_.options.arrows === true ) {
443
444 _.$prevArrow = $(_.options.prevArrow).addClass('slick-arrow');
445 _.$nextArrow = $(_.options.nextArrow).addClass('slick-arrow');
446
447 if( _.slideCount > _.options.slidesToShow ) {
448
449 _.$prevArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
450 _.$nextArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');
451
452 if (_.htmlExpr.test(_.options.prevArrow)) {
453 _.$prevArrow.prependTo(_.options.appendArrows);
454 }
455
456 if (_.htmlExpr.test(_.options.nextArrow)) {
457 _.$nextArrow.appendTo(_.options.appendArrows);
458 }
459
460 if (_.options.infinite !== true) {
461 _.$prevArrow
462 .addClass('slick-disabled')
463 .attr('aria-disabled', 'true');
464 }
465
466 } else {
467
468 _.$prevArrow.add( _.$nextArrow )
469
470 .addClass('slick-hidden')
471 .attr({
472 'aria-disabled': 'true',
473 'tabindex': '-1'
474 });
475
476 }
477
478 }
479
480 };
481
482 Slick.prototype.buildDots = function() {
483
484 var _ = this,
485 i, dot;
486
487 if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
488
489 _.$slider.addClass('slick-dotted');
490
491 dot = $('<ul />').addClass(_.options.dotsClass);
492
493 for (i = 0; i <= _.getDotCount(); i += 1) {
494 dot.append($('<li />').append(_.options.customPaging.call(this, _, i)));
495 }
496
497 _.$dots = dot.appendTo(_.options.appendDots);
498
499 _.$dots.find('li').first().addClass('slick-active');
500
501 }
502
503 };
504
505 Slick.prototype.buildOut = function() {
506
507 var _ = this;
508
509 _.$slides =
510 _.$slider
511 .children( _.options.slide + ':not(.slick-cloned)')
512 .addClass('slick-slide');
513
514 _.slideCount = _.$slides.length;
515
516 _.$slides.each(function(index, element) {
517 $(element)
518 .attr('data-slick-index', index)
519 .data('originalStyling', $(element).attr('style') || '');
520 });
521
522 _.$slider.addClass('slick-slider');
523
524 _.$slideTrack = (_.slideCount === 0) ?
525 $('<div class="slick-track"/>').appendTo(_.$slider) :
526 _.$slides.wrapAll('<div class="slick-track"/>').parent();
527
528 _.$list = _.$slideTrack.wrap(
529 '<div class="slick-list"/>').parent();
530 _.$slideTrack.css('opacity', 0);
531
532 if (_.options.centerMode === true || _.options.swipeToSlide === true) {
533 _.options.slidesToScroll = 1;
534 }
535
536 $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');
537
538 _.setupInfinite();
539
540 _.buildArrows();
541
542 _.buildDots();
543
544 _.updateDots();
545
546
547 _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
548
549 if (_.options.draggable === true) {
550 _.$list.addClass('draggable');
551 }
552
553 };
554
555 Slick.prototype.buildRows = function() {
556
557 var _ = this, a, b, c, newSlides, numOfSlides, originalSlides,slidesPerSection;
558
559 newSlides = document.createDocumentFragment();
560 originalSlides = _.$slider.children();
561
562 if(_.options.rows > 0) {
563
564 slidesPerSection = _.options.slidesPerRow * _.options.rows;
565 numOfSlides = Math.ceil(
566 originalSlides.length / slidesPerSection
567 );
568
569 for(a = 0; a < numOfSlides; a++){
570 var slide = document.createElement('div');
571 for(b = 0; b < _.options.rows; b++) {
572 var row = document.createElement('div');
573 for(c = 0; c < _.options.slidesPerRow; c++) {
574 var target = (a * slidesPerSection + ((b * _.options.slidesPerRow) + c));
575 if (originalSlides.get(target)) {
576 row.appendChild(originalSlides.get(target));
577 }
578 }
579 slide.appendChild(row);
580 }
581 newSlides.appendChild(slide);
582 }
583
584 _.$slider.empty().append(newSlides);
585 _.$slider.children().children().children()
586 .css({
587 'width':(100 / _.options.slidesPerRow) + '%',
588 'display': 'inline-block'
589 });
590
591 }
592
593 };
594
595 Slick.prototype.checkResponsive = function(initial, forceUpdate) {
596
597 var _ = this,
598 breakpoint, targetBreakpoint, respondToWidth, triggerBreakpoint = false;
599 var sliderWidth = _.$slider.width();
600 var windowWidth = window.innerWidth || $(window).width();
601
602 if (_.respondTo === 'window') {
603 respondToWidth = windowWidth;
604 } else if (_.respondTo === 'slider') {
605 respondToWidth = sliderWidth;
606 } else if (_.respondTo === 'min') {
607 respondToWidth = Math.min(windowWidth, sliderWidth);
608 }
609
610 if ( _.options.responsive &&
611 _.options.responsive.length &&
612 _.options.responsive !== null) {
613
614 targetBreakpoint = null;
615
616 for (breakpoint in _.breakpoints) {
617 if (_.breakpoints.hasOwnProperty(breakpoint)) {
618 if (_.originalSettings.mobileFirst === false) {
619 if (respondToWidth < _.breakpoints[breakpoint]) {
620 targetBreakpoint = _.breakpoints[breakpoint];
621 }
622 } else {
623 if (respondToWidth > _.breakpoints[breakpoint]) {
624 targetBreakpoint = _.breakpoints[breakpoint];
625 }
626 }
627 }
628 }
629
630 if (targetBreakpoint !== null) {
631 if (_.activeBreakpoint !== null) {
632 if (targetBreakpoint !== _.activeBreakpoint || forceUpdate) {
633 _.activeBreakpoint =
634 targetBreakpoint;
635 if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
636 _.unslick(targetBreakpoint);
637 } else {
638 _.options = $.extend({}, _.originalSettings,
639 _.breakpointSettings[
640 targetBreakpoint]);
641 if (initial === true) {
642 _.currentSlide = _.options.initialSlide;
643 }
644 _.refresh(initial);
645 }
646 triggerBreakpoint = targetBreakpoint;
647 }
648 } else {
649 _.activeBreakpoint = targetBreakpoint;
650 if (_.breakpointSettings[targetBreakpoint] === 'unslick') {
651 _.unslick(targetBreakpoint);
652 } else {
653 _.options = $.extend({}, _.originalSettings,
654 _.breakpointSettings[
655 targetBreakpoint]);
656 if (initial === true) {
657 _.currentSlide = _.options.initialSlide;
658 }
659 _.refresh(initial);
660 }
661 triggerBreakpoint = targetBreakpoint;
662 }
663 } else {
664 if (_.activeBreakpoint !== null) {
665 _.activeBreakpoint = null;
666 _.options = _.originalSettings;
667 if (initial === true) {
668 _.currentSlide = _.options.initialSlide;
669 }
670 _.refresh(initial);
671 triggerBreakpoint = targetBreakpoint;
672 }
673 }
674
675 // only trigger breakpoints during an actual break. not on initialize.
676 if( !initial && triggerBreakpoint !== false ) {
677 _.$slider.trigger('breakpoint', [_, triggerBreakpoint]);
678 }
679 }
680
681 };
682
683 Slick.prototype.changeSlide = function(event, dontAnimate) {
684
685 var _ = this,
686 $target = $(event.currentTarget),
687 indexOffset, slideOffset, unevenOffset;
688
689 // If target is a link, prevent default action.
690 if($target.is('a')) {
691 event.preventDefault();
692 }
693
694 // If target is not the <li> element (ie: a child), find the <li>.
695 if(!$target.is('li')) {
696 $target = $target.closest('li');
697 }
698
699 unevenOffset = (_.slideCount % _.options.slidesToScroll !== 0);
700 indexOffset = unevenOffset ? 0 : (_.slideCount - _.currentSlide) % _.options.slidesToScroll;
701
702 switch (event.data.message) {
703
704 case 'previous':
705 slideOffset = indexOffset === 0 ? _.options.slidesToScroll : _.options.slidesToShow - indexOffset;
706 if (_.slideCount > _.options.slidesToShow) {
707 _.slideHandler(_.currentSlide - slideOffset, false, dontAnimate);
708 }
709 break;
710
711 case 'next':
712 slideOffset = indexOffset === 0 ? _.options.slidesToScroll : indexOffset;
713 if (_.slideCount > _.options.slidesToShow) {
714 _.slideHandler(_.currentSlide + slideOffset, false, dontAnimate);
715 }
716 break;
717
718 case 'index':
719 var index = event.data.index === 0 ? 0 :
720 event.data.index || $target.index() * _.options.slidesToScroll;
721
722 _.slideHandler(_.checkNavigable(index), false, dontAnimate);
723 $target.children().trigger('focus');
724 break;
725
726 default:
727 return;
728 }
729
730 };
731
732 Slick.prototype.checkNavigable = function(index) {
733
734 var _ = this,
735 navigables, prevNavigable;
736
737 navigables = _.getNavigableIndexes();
738 prevNavigable = 0;
739 if (index > navigables[navigables.length - 1]) {
740 index = navigables[navigables.length - 1];
741 } else {
742 for (var n in navigables) {
743 if (index < navigables[n]) {
744 index = prevNavigable;
745 break;
746 }
747 prevNavigable = navigables[n];
748 }
749 }
750
751 return index;
752 };
753
754 Slick.prototype.cleanUpEvents = function() {
755
756 var _ = this;
757
758 if (_.options.dots && _.$dots !== null) {
759
760 $('li', _.$dots)
761 .off('click.slick', _.changeSlide)
762 .off('mouseenter.slick', $.proxy(_.interrupt, _, true))
763 .off('mouseleave.slick', $.proxy(_.interrupt, _, false));
764
765 if (_.options.accessibility === true) {
766 _.$dots.off('keydown.slick', _.keyHandler);
767 }
768 }
769
770 _.$slider.off('focus.slick blur.slick');
771
772 if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
773 _.$prevArrow && _.$prevArrow.off('click.slick', _.changeSlide);
774 _.$nextArrow && _.$nextArrow.off('click.slick', _.changeSlide);
775
776 if (_.options.accessibility === true) {
777 _.$prevArrow && _.$prevArrow.off('keydown.slick', _.keyHandler);
778 _.$nextArrow && _.$nextArrow.off('keydown.slick', _.keyHandler);
779 }
780 }
781
782 _.$list.off('touchstart.slick mousedown.slick', _.swipeHandler);
783 _.$list.off('touchmove.slick mousemove.slick', _.swipeHandler);
784 _.$list.off('touchend.slick mouseup.slick', _.swipeHandler);
785 _.$list.off('touchcancel.slick mouseleave.slick', _.swipeHandler);
786
787 _.$list.off('click.slick', _.clickHandler);
788
789 $(document).off(_.visibilityChange, _.visibility);
790
791 _.cleanUpSlideEvents();
792
793 if (_.options.accessibility === true) {
794 _.$list.off('keydown.slick', _.keyHandler);
795 }
796
797 if (_.options.focusOnSelect === true) {
798 $(_.$slideTrack).children().off('click.slick', _.selectHandler);
799 }
800
801 $(window).off('orientationchange.slick.slick-' + _.instanceUid, _.orientationChange);
802
803 $(window).off('resize.slick.slick-' + _.instanceUid, _.resize);
804
805 $('[draggable!=true]', _.$slideTrack).off('dragstart', _.preventDefault);
806
807 $(window).off('load.slick.slick-' + _.instanceUid, _.setPosition);
808
809 };
810
811 Slick.prototype.cleanUpSlideEvents = function() {
812
813 var _ = this;
814
815 _.$list.off('mouseenter.slick', $.proxy(_.interrupt, _, true));
816 _.$list.off('mouseleave.slick', $.proxy(_.interrupt, _, false));
817
818 };
819
820 Slick.prototype.cleanUpRows = function() {
821
822 var _ = this, originalSlides;
823
824 if(_.options.rows > 0) {
825 originalSlides = _.$slides.children().children();
826 originalSlides.removeAttr('style');
827 _.$slider.empty().append(originalSlides);
828 }
829
830 };
831
832 Slick.prototype.clickHandler = function(event) {
833
834 var _ = this;
835
836 if (_.shouldClick === false) {
837 event.stopImmediatePropagation();
838 event.stopPropagation();
839 event.preventDefault();
840 }
841
842 };
843
844 Slick.prototype.destroy = function(refresh) {
845
846 var _ = this;
847
848 _.autoPlayClear();
849
850 _.touchObject = {};
851
852 _.cleanUpEvents();
853
854 $('.slick-cloned', _.$slider).detach();
855
856 if (_.$dots) {
857 _.$dots.remove();
858 }
859
860 if ( _.$prevArrow && _.$prevArrow.length ) {
861
862 _.$prevArrow
863 .removeClass('slick-disabled slick-arrow slick-hidden')
864 .removeAttr('aria-hidden aria-disabled tabindex')
865 .css('display','');
866
867 if ( _.htmlExpr.test( _.options.prevArrow )) {
868 _.$prevArrow.remove();
869 }
870 }
871
872 if ( _.$nextArrow && _.$nextArrow.length ) {
873
874 _.$nextArrow
875 .removeClass('slick-disabled slick-arrow slick-hidden')
876 .removeAttr('aria-hidden aria-disabled tabindex')
877 .css('display','');
878
879 if ( _.htmlExpr.test( _.options.nextArrow )) {
880 _.$nextArrow.remove();
881 }
882 }
883
884
885 if (_.$slides) {
886
887 _.$slides
888 .removeClass('slick-slide slick-active slick-center slick-visible slick-current')
889 .removeAttr('aria-hidden')
890 .removeAttr('data-slick-index')
891 .each(function(){
892 $(this).attr('style', $(this).data('originalStyling'));
893 });
894
895 _.$slideTrack.children(this.options.slide).detach();
896
897 _.$slideTrack.detach();
898
899 _.$list.detach();
900
901 _.$slider.append(_.$slides);
902 }
903
904 _.cleanUpRows();
905
906 _.$slider.removeClass('slick-slider');
907 _.$slider.removeClass('slick-initialized');
908 _.$slider.removeClass('slick-dotted');
909
910 _.unslicked = true;
911
912 if(!refresh) {
913 _.$slider.trigger('destroy', [_]);
914 }
915
916 };
917
918 Slick.prototype.disableTransition = function(slide) {
919
920 var _ = this,
921 transition = {};
922
923 transition[_.transitionType] = '';
924
925 if (_.options.fade === false) {
926 _.$slideTrack.css(transition);
927 } else {
928 _.$slides.eq(slide).css(transition);
929 }
930
931 };
932
933 Slick.prototype.fadeSlide = function(slideIndex, callback) {
934
935 var _ = this;
936
937 if (_.cssTransitions === false) {
938
939 _.$slides.eq(slideIndex).css({
940 zIndex: _.options.zIndex
941 });
942
943 _.$slides.eq(slideIndex).animate({
944 opacity: 1
945 }, _.options.speed, _.options.easing, callback);
946
947 } else {
948
949 _.applyTransition(slideIndex);
950
951 _.$slides.eq(slideIndex).css({
952 opacity: 1,
953 zIndex: _.options.zIndex
954 });
955
956 if (callback) {
957 setTimeout(function() {
958
959 _.disableTransition(slideIndex);
960
961 callback.call();
962 }, _.options.speed);
963 }
964
965 }
966
967 };
968
969 Slick.prototype.fadeSlideOut = function(slideIndex) {
970
971 var _ = this;
972
973 if (_.cssTransitions === false) {
974
975 _.$slides.eq(slideIndex).animate({
976 opacity: 0,
977 zIndex: _.options.zIndex - 2
978 }, _.options.speed, _.options.easing);
979
980 } else {
981
982 _.applyTransition(slideIndex);
983
984 _.$slides.eq(slideIndex).css({
985 opacity: 0,
986 zIndex: _.options.zIndex - 2
987 });
988
989 }
990
991 };
992
993 Slick.prototype.filterSlides = Slick.prototype.slickFilter = function(filter) {
994
995 var _ = this;
996
997 if (filter !== null) {
998
999 _.$slidesCache = _.$slides;
1000
1001 _.unload();
1002
1003 _.$slideTrack.children(this.options.slide).detach();
1004
1005 _.$slidesCache.filter(filter).appendTo(_.$slideTrack);
1006
1007 _.reinit();
1008
1009 }
1010
1011 };
1012
1013 Slick.prototype.focusHandler = function() {
1014
1015 var _ = this;
1016
1017 _.$slider
1018 .off('focus.slick blur.slick')
1019 .on('focus.slick blur.slick', '*', function(event) {
1020
1021 event.stopImmediatePropagation();
1022 var $sf = $(this);
1023
1024 setTimeout(function() {
1025
1026 if( _.options.pauseOnFocus ) {
1027 _.focussed = $sf.is(':focus');
1028 _.autoPlay();
1029 }
1030
1031 }, 0);
1032
1033 });
1034 };
1035
1036 Slick.prototype.getCurrent = Slick.prototype.slickCurrentSlide = function() {
1037
1038 var _ = this;
1039 return _.currentSlide;
1040
1041 };
1042
1043 Slick.prototype.getDotCount = function() {
1044
1045 var _ = this;
1046
1047 var breakPoint = 0;
1048 var counter = 0;
1049 var pagerQty = 0;
1050
1051 if (_.options.infinite === true) {
1052 if (_.slideCount <= _.options.slidesToShow) {
1053 ++pagerQty;
1054 } else {
1055 while (breakPoint < _.slideCount) {
1056 ++pagerQty;
1057 breakPoint = counter + _.options.slidesToScroll;
1058 counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
1059 }
1060 }
1061 } else if (_.options.centerMode === true) {
1062 pagerQty = _.slideCount;
1063 } else if(!_.options.asNavFor) {
1064 pagerQty = 1 + Math.ceil((_.slideCount - _.options.slidesToShow) / _.options.slidesToScroll);
1065 }else {
1066 while (breakPoint < _.slideCount) {
1067 ++pagerQty;
1068 breakPoint = counter + _.options.slidesToScroll;
1069 counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
1070 }
1071 }
1072
1073 return pagerQty - 1;
1074
1075 };
1076
1077 Slick.prototype.getLeft = function(slideIndex) {
1078
1079 var _ = this,
1080 targetLeft,
1081 verticalHeight,
1082 verticalOffset = 0,
1083 targetSlide,
1084 coef;
1085
1086 _.slideOffset = 0;
1087 verticalHeight = _.$slides.first().outerHeight(true);
1088
1089 if (_.options.infinite === true) {
1090 if (_.slideCount > _.options.slidesToShow) {
1091 _.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;
1092 coef = -1
1093
1094 if (_.options.vertical === true && _.options.centerMode === true) {
1095 if (_.options.slidesToShow === 2) {
1096 coef = -1.5;
1097 } else if (_.options.slidesToShow === 1) {
1098 coef = -2
1099 }
1100 }
1101 verticalOffset = (verticalHeight * _.options.slidesToShow) * coef;
1102 }
1103 if (_.slideCount % _.options.slidesToScroll !== 0) {
1104 if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {
1105 if (slideIndex > _.slideCount) {
1106 _.slideOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * _.slideWidth) * -1;
1107 verticalOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * verticalHeight) * -1;
1108 } else {
1109 _.slideOffset = ((_.slideCount % _.options.slidesToScroll) * _.slideWidth) * -1;
1110 verticalOffset = ((_.slideCount % _.options.slidesToScroll) * verticalHeight) * -1;
1111 }
1112 }
1113 }
1114 } else {
1115 if (slideIndex + _.options.slidesToShow > _.slideCount) {
1116 _.slideOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * _.slideWidth;
1117 verticalOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * verticalHeight;
1118 }
1119 }
1120
1121 if (_.slideCount <= _.options.slidesToShow) {
1122 _.slideOffset = 0;
1123 verticalOffset = 0;
1124 }
1125
1126 if (_.options.centerMode === true && _.slideCount <= _.options.slidesToShow) {
1127 _.slideOffset = ((_.slideWidth * Math.floor(_.options.slidesToShow)) / 2) - ((_.slideWidth * _.slideCount) / 2);
1128 } else if (_.options.centerMode === true && _.options.infinite === true) {
1129 _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;
1130 } else if (_.options.centerMode === true) {
1131 _.slideOffset = 0;
1132 _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);
1133 }
1134
1135 if (_.options.vertical === false) {
1136 targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;
1137 } else {
1138 targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;
1139 }
1140
1141 if (_.options.variableWidth === true) {
1142
1143 if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
1144 targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
1145 } else {
1146 targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow);
1147 }
1148
1149 if (_.options.rtl === true) {
1150 if (targetSlide[0]) {
1151 targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
1152 } else {
1153 targetLeft = 0;
1154 }
1155 } else {
1156 targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
1157 }
1158
1159 if (_.options.centerMode === true) {
1160 if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {
1161 targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);
1162 } else {
1163 targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow + 1);
1164 }
1165
1166 if (_.options.rtl === true) {
1167 if (targetSlide[0]) {
1168 targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;
1169 } else {
1170 targetLeft = 0;
1171 }
1172 } else {
1173 targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;
1174 }
1175
1176 targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2;
1177 }
1178 }
1179
1180 return targetLeft;
1181
1182 };
1183
1184 Slick.prototype.getOption = Slick.prototype.slickGetOption = function(option) {
1185
1186 var _ = this;
1187
1188 return _.options[option];
1189
1190 };
1191
1192 Slick.prototype.getNavigableIndexes = function() {
1193
1194 var _ = this,
1195 breakPoint = 0,
1196 counter = 0,
1197 indexes = [],
1198 max;
1199
1200 if (_.options.infinite === false) {
1201 max = _.slideCount;
1202 } else {
1203 breakPoint = _.options.slidesToScroll * -1;
1204 counter = _.options.slidesToScroll * -1;
1205 max = _.slideCount * 2;
1206 }
1207
1208 while (breakPoint < max) {
1209 indexes.push(breakPoint);
1210 breakPoint = counter + _.options.slidesToScroll;
1211 counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;
1212 }
1213
1214 return indexes;
1215
1216 };
1217
1218 Slick.prototype.getSlick = function() {
1219
1220 return this;
1221
1222 };
1223
1224 Slick.prototype.getSlideCount = function() {
1225
1226 var _ = this,
1227 slidesTraversed, swipedSlide, centerOffset;
1228
1229 centerOffset = _.options.centerMode === true ? _.slideWidth * Math.floor(_.options.slidesToShow / 2) : 0;
1230
1231 if (_.options.swipeToSlide === true) {
1232 _.$slideTrack.find('.slick-slide').each(function(index, slide) {
1233 if (slide.offsetLeft - centerOffset + ($(slide).outerWidth() / 2) > (_.swipeLeft * -1)) {
1234 swipedSlide = slide;
1235 return false;
1236 }
1237 });
1238
1239 slidesTraversed = Math.abs($(swipedSlide).attr('data-slick-index') - _.currentSlide) || 1;
1240
1241 return slidesTraversed;
1242
1243 } else {
1244 return _.options.slidesToScroll;
1245 }
1246
1247 };
1248
1249 Slick.prototype.goTo = Slick.prototype.slickGoTo = function(slide, dontAnimate) {
1250
1251 var _ = this;
1252
1253 _.changeSlide({
1254 data: {
1255 message: 'index',
1256 index: parseInt(slide)
1257 }
1258 }, dontAnimate);
1259
1260 };
1261
1262 Slick.prototype.init = function(creation) {
1263
1264 var _ = this;
1265
1266 if (!$(_.$slider).hasClass('slick-initialized')) {
1267
1268 $(_.$slider).addClass('slick-initialized');
1269
1270 _.buildRows();
1271 _.buildOut();
1272 _.setProps();
1273 _.startLoad();
1274 _.loadSlider();
1275 _.initializeEvents();
1276 _.updateArrows();
1277 _.updateDots();
1278 _.checkResponsive(true);
1279 _.focusHandler();
1280
1281 }
1282
1283 if (creation) {
1284 _.$slider.trigger('init', [_]);
1285 }
1286
1287 if (_.options.accessibility === true) {
1288 _.initADA();
1289 }
1290
1291 if ( _.options.autoplay ) {
1292
1293 _.paused = false;
1294 _.autoPlay();
1295
1296 }
1297
1298 };
1299
1300 Slick.prototype.initADA = function() {
1301 var _ = this,
1302 numDotGroups = Math.ceil(_.slideCount / _.options.slidesToShow),
1303 tabControlIndexes = _.getNavigableIndexes().filter(function(val) {
1304 return (val >= 0) && (val < _.slideCount);
1305 });
1306
1307 _.$slides.add(_.$slideTrack.find('.slick-cloned')).attr({
1308 'aria-hidden': 'true',
1309 'tabindex': '-1'
1310 }).find('a, input, button, select').attr({
1311 'tabindex': '-1'
1312 });
1313
1314 if (_.$dots !== null) {
1315 _.$slides.not(_.$slideTrack.find('.slick-cloned')).each(function(i) {
1316 var slideControlIndex = tabControlIndexes.indexOf(i);
1317
1318 $(this).attr({
1319 'role': 'tabpanel',
1320 'id': 'slick-slide' + _.instanceUid + i,
1321 'tabindex': -1
1322 });
1323
1324 if (slideControlIndex !== -1) {
1325 var ariaButtonControl = 'slick-slide-control' + _.instanceUid + slideControlIndex
1326 if ($('#' + ariaButtonControl).length) {
1327 $(this).attr({
1328 'aria-describedby': ariaButtonControl
1329 });
1330 }
1331 }
1332 });
1333
1334 _.$dots.attr('role', 'tablist').find('li').each(function(i) {
1335 var mappedSlideIndex = tabControlIndexes[i];
1336
1337 $(this).attr({
1338 'role': 'presentation'
1339 });
1340
1341 $(this).find('button').first().attr({
1342 'role': 'tab',
1343 'id': 'slick-slide-control' + _.instanceUid + i,
1344 'aria-controls': 'slick-slide' + _.instanceUid + mappedSlideIndex,
1345 'aria-label': (i + 1) + ' of ' + numDotGroups,
1346 'aria-selected': null,
1347 'tabindex': '-1'
1348 });
1349
1350 }).eq(_.currentSlide).find('button').attr({
1351 'aria-selected': 'true',
1352 'tabindex': '0'
1353 }).end();
1354 }
1355
1356 for (var i=_.currentSlide, max=i+_.options.slidesToShow; i < max; i++) {
1357 if (_.options.focusOnChange) {
1358 _.$slides.eq(i).attr({'tabindex': '0'});
1359 } else {
1360 _.$slides.eq(i).removeAttr('tabindex');
1361 }
1362 }
1363
1364 _.activateADA();
1365
1366 };
1367
1368 Slick.prototype.initArrowEvents = function() {
1369
1370 var _ = this;
1371
1372 if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1373 _.$prevArrow
1374 .off('click.slick')
1375 .on('click.slick', {
1376 message: 'previous'
1377 }, _.changeSlide);
1378 _.$nextArrow
1379 .off('click.slick')
1380 .on('click.slick', {
1381 message: 'next'
1382 }, _.changeSlide);
1383
1384 if (_.options.accessibility === true) {
1385 _.$prevArrow.on('keydown.slick', _.keyHandler);
1386 _.$nextArrow.on('keydown.slick', _.keyHandler);
1387 }
1388 }
1389
1390 };
1391
1392 Slick.prototype.initDotEvents = function() {
1393
1394 var _ = this;
1395
1396 if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1397 $('li', _.$dots).on('click.slick', {
1398 message: 'index'
1399 }, _.changeSlide);
1400
1401 if (_.options.accessibility === true) {
1402 _.$dots.on('keydown.slick', _.keyHandler);
1403 }
1404 }
1405
1406 if (_.options.dots === true && _.options.pauseOnDotsHover === true && _.slideCount > _.options.slidesToShow) {
1407
1408 $('li', _.$dots)
1409 .on('mouseenter.slick', $.proxy(_.interrupt, _, true))
1410 .on('mouseleave.slick', $.proxy(_.interrupt, _, false));
1411
1412 }
1413
1414 };
1415
1416 Slick.prototype.initSlideEvents = function() {
1417
1418 var _ = this;
1419
1420 if ( _.options.pauseOnHover ) {
1421
1422 _.$list.on('mouseenter.slick', $.proxy(_.interrupt, _, true));
1423 _.$list.on('mouseleave.slick', $.proxy(_.interrupt, _, false));
1424
1425 }
1426
1427 };
1428
1429 Slick.prototype.initializeEvents = function() {
1430
1431 var _ = this;
1432
1433 _.initArrowEvents();
1434
1435 _.initDotEvents();
1436 _.initSlideEvents();
1437
1438 _.$list.on('touchstart.slick mousedown.slick', {
1439 action: 'start'
1440 }, _.swipeHandler);
1441 _.$list.on('touchmove.slick mousemove.slick', {
1442 action: 'move'
1443 }, _.swipeHandler);
1444 _.$list.on('touchend.slick mouseup.slick', {
1445 action: 'end'
1446 }, _.swipeHandler);
1447 _.$list.on('touchcancel.slick mouseleave.slick', {
1448 action: 'end'
1449 }, _.swipeHandler);
1450
1451 _.$list.on('click.slick', _.clickHandler);
1452
1453 $(document).on(_.visibilityChange, $.proxy(_.visibility, _));
1454
1455 if (_.options.accessibility === true) {
1456 _.$list.on('keydown.slick', _.keyHandler);
1457 }
1458
1459 if (_.options.focusOnSelect === true) {
1460 $(_.$slideTrack).children().on('click.slick', _.selectHandler);
1461 }
1462
1463 $(window).on('orientationchange.slick.slick-' + _.instanceUid, $.proxy(_.orientationChange, _));
1464
1465 $(window).on('resize.slick.slick-' + _.instanceUid, $.proxy(_.resize, _));
1466
1467 $('[draggable!=true]', _.$slideTrack).on('dragstart', _.preventDefault);
1468
1469 $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);
1470 $(_.setPosition);
1471
1472 };
1473
1474 Slick.prototype.initUI = function() {
1475
1476 var _ = this;
1477
1478 if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1479
1480 _.$prevArrow.show();
1481 _.$nextArrow.show();
1482
1483 }
1484
1485 if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1486
1487 _.$dots.show();
1488
1489 }
1490
1491 };
1492
1493 Slick.prototype.keyHandler = function(event) {
1494
1495 var _ = this;
1496 //Dont slide if the cursor is inside the form fields and arrow keys are pressed
1497 if(!event.target.tagName.match('TEXTAREA|INPUT|SELECT')) {
1498 if (event.keyCode === 37 && _.options.accessibility === true) {
1499 _.changeSlide({
1500 data: {
1501 message: _.options.rtl === true ? 'next' : 'previous'
1502 }
1503 });
1504 } else if (event.keyCode === 39 && _.options.accessibility === true) {
1505 _.changeSlide({
1506 data: {
1507 message: _.options.rtl === true ? 'previous' : 'next'
1508 }
1509 });
1510 }
1511 }
1512
1513 };
1514
1515 Slick.prototype.lazyLoad = function() {
1516
1517 var _ = this,
1518 loadRange, cloneRange, rangeStart, rangeEnd;
1519
1520 function loadImages(imagesScope) {
1521
1522 $('img[data-lazy]', imagesScope).each(function() {
1523
1524 var image = $(this),
1525 imageSource = $(this).attr('data-lazy'),
1526 imageSrcSet = $(this).attr('data-srcset'),
1527 imageSizes = $(this).attr('data-sizes') || _.$slider.attr('data-sizes'),
1528 imageToLoad = document.createElement('img');
1529
1530 imageToLoad.onload = function() {
1531
1532 image
1533 .animate({ opacity: 0 }, 100, function() {
1534
1535 if (imageSrcSet) {
1536 image
1537 .attr('srcset', imageSrcSet );
1538
1539 if (imageSizes) {
1540 image
1541 .attr('sizes', imageSizes );
1542 }
1543 }
1544
1545 image
1546 .attr('src', imageSource)
1547 .animate({ opacity: 1 }, 200, function() {
1548 image
1549 .removeAttr('data-lazy data-srcset data-sizes')
1550 .removeClass('slick-loading');
1551 });
1552 _.$slider.trigger('lazyLoaded', [_, image, imageSource]);
1553 });
1554
1555 };
1556
1557 imageToLoad.onerror = function() {
1558
1559 image
1560 .removeAttr( 'data-lazy' )
1561 .removeClass( 'slick-loading' )
1562 .addClass( 'slick-lazyload-error' );
1563
1564 _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
1565
1566 };
1567
1568 imageToLoad.src = imageSource;
1569
1570 });
1571
1572 }
1573
1574 if (_.options.centerMode === true) {
1575 if (_.options.infinite === true) {
1576 rangeStart = _.currentSlide + (_.options.slidesToShow / 2 + 1);
1577 rangeEnd = rangeStart + _.options.slidesToShow + 2;
1578 } else {
1579 rangeStart = Math.max(0, _.currentSlide - (_.options.slidesToShow / 2 + 1));
1580 rangeEnd = 2 + (_.options.slidesToShow / 2 + 1) + _.currentSlide;
1581 }
1582 } else {
1583 rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;
1584 rangeEnd = Math.ceil(rangeStart + _.options.slidesToShow);
1585 if (_.options.fade === true) {
1586 if (rangeStart > 0) rangeStart--;
1587 if (rangeEnd <= _.slideCount) rangeEnd++;
1588 }
1589 }
1590
1591 loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);
1592
1593 if (_.options.lazyLoad === 'anticipated') {
1594 var prevSlide = rangeStart - 1,
1595 nextSlide = rangeEnd,
1596 $slides = _.$slider.find('.slick-slide');
1597
1598 for (var i = 0; i < _.options.slidesToScroll; i++) {
1599 if (prevSlide < 0) prevSlide = _.slideCount - 1;
1600 loadRange = loadRange.add($slides.eq(prevSlide));
1601 loadRange = loadRange.add($slides.eq(nextSlide));
1602 prevSlide--;
1603 nextSlide++;
1604 }
1605 }
1606
1607 loadImages(loadRange);
1608
1609 if (_.slideCount <= _.options.slidesToShow) {
1610 cloneRange = _.$slider.find('.slick-slide');
1611 loadImages(cloneRange);
1612 } else
1613 if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
1614 cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);
1615 loadImages(cloneRange);
1616 } else if (_.currentSlide === 0) {
1617 cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
1618 loadImages(cloneRange);
1619 }
1620
1621 };
1622
1623 Slick.prototype.loadSlider = function() {
1624
1625 var _ = this;
1626
1627 _.setPosition();
1628
1629 _.$slideTrack.css({
1630 opacity: 1
1631 });
1632
1633 _.$slider.removeClass('slick-loading');
1634
1635 _.initUI();
1636
1637 if (_.options.lazyLoad === 'progressive') {
1638 _.progressiveLazyLoad();
1639 }
1640
1641 };
1642
1643 Slick.prototype.next = Slick.prototype.slickNext = function() {
1644
1645 var _ = this;
1646
1647 _.changeSlide({
1648 data: {
1649 message: 'next'
1650 }
1651 });
1652
1653 };
1654
1655 Slick.prototype.orientationChange = function() {
1656
1657 var _ = this;
1658
1659 _.checkResponsive();
1660 _.setPosition();
1661
1662 };
1663
1664 Slick.prototype.pause = Slick.prototype.slickPause = function() {
1665
1666 var _ = this;
1667
1668 _.autoPlayClear();
1669 _.paused = true;
1670
1671 };
1672
1673 Slick.prototype.play = Slick.prototype.slickPlay = function() {
1674
1675 var _ = this;
1676
1677 _.autoPlay();
1678 _.options.autoplay = true;
1679 _.paused = false;
1680 _.focussed = false;
1681 _.interrupted = false;
1682
1683 };
1684
1685 Slick.prototype.postSlide = function(index) {
1686
1687 var _ = this;
1688
1689 if( !_.unslicked ) {
1690
1691 _.$slider.trigger('afterChange', [_, index]);
1692
1693 _.animating = false;
1694
1695 if (_.slideCount > _.options.slidesToShow) {
1696 _.setPosition();
1697 }
1698
1699 _.swipeLeft = null;
1700
1701 if ( _.options.autoplay ) {
1702 _.autoPlay();
1703 }
1704
1705 if (_.options.accessibility === true) {
1706 _.initADA();
1707
1708 if (_.options.focusOnChange) {
1709 var $currentSlide = $(_.$slides.get(_.currentSlide));
1710 $currentSlide.attr('tabindex', 0).focus();
1711 }
1712 }
1713
1714 }
1715
1716 };
1717
1718 Slick.prototype.prev = Slick.prototype.slickPrev = function() {
1719
1720 var _ = this;
1721
1722 _.changeSlide({
1723 data: {
1724 message: 'previous'
1725 }
1726 });
1727
1728 };
1729
1730 Slick.prototype.preventDefault = function(event) {
1731
1732 event.preventDefault();
1733
1734 };
1735
1736 Slick.prototype.progressiveLazyLoad = function( tryCount ) {
1737
1738 tryCount = tryCount || 1;
1739
1740 var _ = this,
1741 $imgsToLoad = $( 'img[data-lazy]', _.$slider ),
1742 image,
1743 imageSource,
1744 imageSrcSet,
1745 imageSizes,
1746 imageToLoad;
1747
1748 if ( $imgsToLoad.length ) {
1749
1750 image = $imgsToLoad.first();
1751 imageSource = image.attr('data-lazy');
1752 imageSrcSet = image.attr('data-srcset');
1753 imageSizes = image.attr('data-sizes') || _.$slider.attr('data-sizes');
1754 imageToLoad = document.createElement('img');
1755
1756 imageToLoad.onload = function() {
1757
1758 if (imageSrcSet) {
1759 image
1760 .attr('srcset', imageSrcSet );
1761
1762 if (imageSizes) {
1763 image
1764 .attr('sizes', imageSizes );
1765 }
1766 }
1767
1768 image
1769 .attr( 'src', imageSource )
1770 .removeAttr('data-lazy data-srcset data-sizes')
1771 .removeClass('slick-loading');
1772
1773 if ( _.options.adaptiveHeight === true ) {
1774 _.setPosition();
1775 }
1776
1777 _.$slider.trigger('lazyLoaded', [ _, image, imageSource ]);
1778 _.progressiveLazyLoad();
1779
1780 };
1781
1782 imageToLoad.onerror = function() {
1783
1784 if ( tryCount < 3 ) {
1785
1786 /**
1787 * try to load the image 3 times,
1788 * leave a slight delay so we don't get
1789 * servers blocking the request.
1790 */
1791 setTimeout( function() {
1792 _.progressiveLazyLoad( tryCount + 1 );
1793 }, 500 );
1794
1795 } else {
1796
1797 image
1798 .removeAttr( 'data-lazy' )
1799 .removeClass( 'slick-loading' )
1800 .addClass( 'slick-lazyload-error' );
1801
1802 _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);
1803
1804 _.progressiveLazyLoad();
1805
1806 }
1807
1808 };
1809
1810 imageToLoad.src = imageSource;
1811
1812 } else {
1813
1814 _.$slider.trigger('allImagesLoaded', [ _ ]);
1815
1816 }
1817
1818 };
1819
1820 Slick.prototype.refresh = function( initializing ) {
1821
1822 var _ = this, currentSlide, lastVisibleIndex;
1823
1824 lastVisibleIndex = _.slideCount - _.options.slidesToShow;
1825
1826 // in non-infinite sliders, we don't want to go past the
1827 // last visible index.
1828 if( !_.options.infinite && ( _.currentSlide > lastVisibleIndex )) {
1829 _.currentSlide = lastVisibleIndex;
1830 }
1831
1832 // if less slides than to show, go to start.
1833 if ( _.slideCount <= _.options.slidesToShow ) {
1834 _.currentSlide = 0;
1835
1836 }
1837
1838 currentSlide = _.currentSlide;
1839
1840 _.destroy(true);
1841
1842 $.extend(_, _.initials, { currentSlide: currentSlide });
1843
1844 _.init();
1845
1846 if( !initializing ) {
1847
1848 _.changeSlide({
1849 data: {
1850 message: 'index',
1851 index: currentSlide
1852 }
1853 }, false);
1854
1855 }
1856
1857 };
1858
1859 Slick.prototype.registerBreakpoints = function() {
1860
1861 var _ = this, breakpoint, currentBreakpoint, l,
1862 responsiveSettings = _.options.responsive || null;
1863
1864 if ( $.type(responsiveSettings) === 'array' && responsiveSettings.length ) {
1865
1866 _.respondTo = _.options.respondTo || 'window';
1867
1868 for ( breakpoint in responsiveSettings ) {
1869
1870 l = _.breakpoints.length-1;
1871
1872 if (responsiveSettings.hasOwnProperty(breakpoint)) {
1873 currentBreakpoint = responsiveSettings[breakpoint].breakpoint;
1874
1875 // loop through the breakpoints and cut out any existing
1876 // ones with the same breakpoint number, we don't want dupes.
1877 while( l >= 0 ) {
1878 if( _.breakpoints[l] && _.breakpoints[l] === currentBreakpoint ) {
1879 _.breakpoints.splice(l,1);
1880 }
1881 l--;
1882 }
1883
1884 _.breakpoints.push(currentBreakpoint);
1885 _.breakpointSettings[currentBreakpoint] = responsiveSettings[breakpoint].settings;
1886
1887 }
1888
1889 }
1890
1891 _.breakpoints.sort(function(a, b) {
1892 return ( _.options.mobileFirst ) ? a-b : b-a;
1893 });
1894
1895 }
1896
1897 };
1898
1899 Slick.prototype.reinit = function() {
1900
1901 var _ = this;
1902
1903 _.$slides =
1904 _.$slideTrack
1905 .children(_.options.slide)
1906 .addClass('slick-slide');
1907
1908 _.slideCount = _.$slides.length;
1909
1910 if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
1911 _.currentSlide = _.currentSlide - _.options.slidesToScroll;
1912 }
1913
1914 if (_.slideCount <= _.options.slidesToShow) {
1915 _.currentSlide = 0;
1916 }
1917
1918 _.registerBreakpoints();
1919
1920 _.setProps();
1921 _.setupInfinite();
1922 _.buildArrows();
1923 _.updateArrows();
1924 _.initArrowEvents();
1925 _.buildDots();
1926 _.updateDots();
1927 _.initDotEvents();
1928 _.cleanUpSlideEvents();
1929 _.initSlideEvents();
1930
1931 _.checkResponsive(false, true);
1932
1933 if (_.options.focusOnSelect === true) {
1934 $(_.$slideTrack).children().on('click.slick', _.selectHandler);
1935 }
1936
1937 _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);
1938
1939 _.setPosition();
1940 _.focusHandler();
1941
1942 _.paused = !_.options.autoplay;
1943 _.autoPlay();
1944
1945 _.$slider.trigger('reInit', [_]);
1946
1947 };
1948
1949 Slick.prototype.resize = function() {
1950
1951 var _ = this;
1952
1953 if ($(window).width() !== _.windowWidth) {
1954 clearTimeout(_.windowDelay);
1955 _.windowDelay = window.setTimeout(function() {
1956 _.windowWidth = $(window).width();
1957 _.checkResponsive();
1958 if( !_.unslicked ) { _.setPosition(); }
1959 }, 50);
1960 }
1961 };
1962
1963 Slick.prototype.removeSlide = Slick.prototype.slickRemove = function(index, removeBefore, removeAll) {
1964
1965 var _ = this;
1966
1967 if (typeof(index) === 'boolean') {
1968 removeBefore = index;
1969 index = removeBefore === true ? 0 : _.slideCount - 1;
1970 } else {
1971 index = removeBefore === true ? --index : index;
1972 }
1973
1974 if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
1975 return false;
1976 }
1977
1978 _.unload();
1979
1980 if (removeAll === true) {
1981 _.$slideTrack.children().remove();
1982 } else {
1983 _.$slideTrack.children(this.options.slide).eq(index).remove();
1984 }
1985
1986 _.$slides = _.$slideTrack.children(this.options.slide);
1987
1988 _.$slideTrack.children(this.options.slide).detach();
1989
1990 _.$slideTrack.append(_.$slides);
1991
1992 _.$slidesCache = _.$slides;
1993
1994 _.reinit();
1995
1996 };
1997
1998 Slick.prototype.setCSS = function(position) {
1999
2000 var _ = this,
2001 positionProps = {},
2002 x, y;
2003
2004 if (_.options.rtl === true) {
2005 position = -position;
2006 }
2007 x = _.positionProp == 'left' ? Math.ceil(position) + 'px' : '0px';
2008 y = _.positionProp == 'top' ? Math.ceil(position) + 'px' : '0px';
2009
2010 positionProps[_.positionProp] = position;
2011
2012 if (_.transformsEnabled === false) {
2013 _.$slideTrack.css(positionProps);
2014 } else {
2015 positionProps = {};
2016 if (_.cssTransitions === false) {
2017 positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';
2018 _.$slideTrack.css(positionProps);
2019 } else {
2020 positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';
2021 _.$slideTrack.css(positionProps);
2022 }
2023 }
2024
2025 };
2026
2027 Slick.prototype.setDimensions = function() {
2028
2029 var _ = this;
2030
2031 if (_.options.vertical === false) {
2032 if (_.options.centerMode === true) {
2033 _.$list.css({
2034 padding: ('0px ' + _.options.centerPadding)
2035 });
2036 }
2037 } else {
2038 _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);
2039 if (_.options.centerMode === true) {
2040 _.$list.css({
2041 padding: (_.options.centerPadding + ' 0px')
2042 });
2043 }
2044 }
2045
2046 _.listWidth = _.$list.width();
2047 _.listHeight = _.$list.height();
2048
2049
2050 if (_.options.vertical === false && _.options.variableWidth === false) {
2051 _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
2052 _.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));
2053
2054 } else if (_.options.variableWidth === true) {
2055 _.$slideTrack.width(5000 * _.slideCount);
2056 } else {
2057 _.slideWidth = Math.ceil(_.listWidth);
2058 _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));
2059 }
2060
2061 var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();
2062 if (_.options.variableWidth === false) _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);
2063
2064 };
2065
2066 Slick.prototype.setFade = function() {
2067
2068 var _ = this,
2069 targetLeft;
2070
2071 _.$slides.each(function(index, element) {
2072 targetLeft = (_.slideWidth * index) * -1;
2073 if (_.options.rtl === true) {
2074 $(element).css({
2075 position: 'relative',
2076 right: targetLeft,
2077 top: 0,
2078 zIndex: _.options.zIndex - 2,
2079 opacity: 0
2080 });
2081 } else {
2082 $(element).css({
2083 position: 'relative',
2084 left: targetLeft,
2085 top: 0,
2086 zIndex: _.options.zIndex - 2,
2087 opacity: 0
2088 });
2089 }
2090 });
2091
2092 _.$slides.eq(_.currentSlide).css({
2093 zIndex: _.options.zIndex - 1,
2094 opacity: 1
2095 });
2096
2097 };
2098
2099 Slick.prototype.setHeight = function() {
2100
2101 var _ = this;
2102
2103 if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {
2104 var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);
2105 _.$list.css('height', targetHeight);
2106 }
2107
2108 };
2109
2110 Slick.prototype.setOption =
2111 Slick.prototype.slickSetOption = function() {
2112
2113 /**
2114 * accepts arguments in format of:
2115 *
2116 * - for changing a single option's value:
2117 * .slick("setOption", option, value, refresh )
2118 *
2119 * - for changing a set of responsive options:
2120 * .slick("setOption", 'responsive', [{}, ...], refresh )
2121 *
2122 * - for updating multiple values at once (not responsive)
2123 * .slick("setOption", { 'option': value, ... }, refresh )
2124 */
2125
2126 var _ = this, l, item, option, value, refresh = false, type;
2127
2128 if( $.type( arguments[0] ) === 'object' ) {
2129
2130 option = arguments[0];
2131 refresh = arguments[1];
2132 type = 'multiple';
2133
2134 } else if ( $.type( arguments[0] ) === 'string' ) {
2135
2136 option = arguments[0];
2137 value = arguments[1];
2138 refresh = arguments[2];
2139
2140 if ( arguments[0] === 'responsive' && $.type( arguments[1] ) === 'array' ) {
2141
2142 type = 'responsive';
2143
2144 } else if ( typeof arguments[1] !== 'undefined' ) {
2145
2146 type = 'single';
2147
2148 }
2149
2150 }
2151
2152 if ( type === 'single' ) {
2153
2154 _.options[option] = value;
2155
2156
2157 } else if ( type === 'multiple' ) {
2158
2159 $.each( option , function( opt, val ) {
2160
2161 _.options[opt] = val;
2162
2163 });
2164
2165
2166 } else if ( type === 'responsive' ) {
2167
2168 for ( item in value ) {
2169
2170 if( $.type( _.options.responsive ) !== 'array' ) {
2171
2172 _.options.responsive = [ value[item] ];
2173
2174 } else {
2175
2176 l = _.options.responsive.length-1;
2177
2178 // loop through the responsive object and splice out duplicates.
2179 while( l >= 0 ) {
2180
2181 if( _.options.responsive[l].breakpoint === value[item].breakpoint ) {
2182
2183 _.options.responsive.splice(l,1);
2184
2185 }
2186
2187 l--;
2188
2189 }
2190
2191 _.options.responsive.push( value[item] );
2192
2193 }
2194
2195 }
2196
2197 }
2198
2199 if ( refresh ) {
2200
2201 _.unload();
2202 _.reinit();
2203
2204 }
2205
2206 };
2207
2208 Slick.prototype.setPosition = function() {
2209
2210 var _ = this;
2211
2212 _.setDimensions();
2213
2214 _.setHeight();
2215
2216 if (_.options.fade === false) {
2217 _.setCSS(_.getLeft(_.currentSlide));
2218 } else {
2219 _.setFade();
2220 }
2221
2222 _.$slider.trigger('setPosition', [_]);
2223
2224 };
2225
2226 Slick.prototype.setProps = function() {
2227
2228 var _ = this,
2229 bodyStyle = document.body.style;
2230
2231 _.positionProp = _.options.vertical === true ? 'top' : 'left';
2232
2233 if (_.positionProp === 'top') {
2234 _.$slider.addClass('slick-vertical');
2235 } else {
2236 _.$slider.removeClass('slick-vertical');
2237 }
2238
2239 if (bodyStyle.WebkitTransition !== undefined ||
2240 bodyStyle.MozTransition !== undefined ||
2241 bodyStyle.msTransition !== undefined) {
2242 if (_.options.useCSS === true) {
2243 _.cssTransitions = true;
2244 }
2245 }
2246
2247 if ( _.options.fade ) {
2248 if ( typeof _.options.zIndex === 'number' ) {
2249 if( _.options.zIndex < 3 ) {
2250 _.options.zIndex = 3;
2251 }
2252 } else {
2253 _.options.zIndex = _.defaults.zIndex;
2254 }
2255 }
2256
2257 if (bodyStyle.OTransform !== undefined) {
2258 _.animType = 'OTransform';
2259 _.transformType = '-o-transform';
2260 _.transitionType = 'OTransition';
2261 if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
2262 }
2263 if (bodyStyle.MozTransform !== undefined) {
2264 _.animType = 'MozTransform';
2265 _.transformType = '-moz-transform';
2266 _.transitionType = 'MozTransition';
2267 if (bodyStyle.perspectiveProperty === undefined && bodyStyle.MozPerspective === undefined) _.animType = false;
2268 }
2269 if (bodyStyle.webkitTransform !== undefined) {
2270 _.animType = 'webkitTransform';
2271 _.transformType = '-webkit-transform';
2272 _.transitionType = 'webkitTransition';
2273 if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;
2274 }
2275 if (bodyStyle.msTransform !== undefined) {
2276 _.animType = 'msTransform';
2277 _.transformType = '-ms-transform';
2278 _.transitionType = 'msTransition';
2279 if (bodyStyle.msTransform === undefined) _.animType = false;
2280 }
2281 if (bodyStyle.transform !== undefined && _.animType !== false) {
2282 _.animType = 'transform';
2283 _.transformType = 'transform';
2284 _.transitionType = 'transition';
2285 }
2286 _.transformsEnabled = _.options.useTransform && (_.animType !== null && _.animType !== false);
2287 };
2288
2289
2290 Slick.prototype.setSlideClasses = function(index) {
2291
2292 var _ = this,
2293 centerOffset, allSlides, indexOffset, remainder;
2294
2295 allSlides = _.$slider
2296 .find('.slick-slide')
2297 .removeClass('slick-active slick-center slick-current')
2298 .attr('aria-hidden', 'true');
2299
2300 _.$slides
2301 .eq(index)
2302 .addClass('slick-current');
2303
2304 if (_.options.centerMode === true) {
2305
2306 var evenCoef = _.options.slidesToShow % 2 === 0 ? 1 : 0;
2307
2308 centerOffset = Math.floor(_.options.slidesToShow / 2);
2309
2310 if (_.options.infinite === true) {
2311
2312 if (index >= centerOffset && index <= (_.slideCount - 1) - centerOffset) {
2313 _.$slides
2314 .slice(index - centerOffset + evenCoef, index + centerOffset + 1)
2315 .addClass('slick-active')
2316 .attr('aria-hidden', 'false');
2317
2318 } else {
2319
2320 indexOffset = _.options.slidesToShow + index;
2321 allSlides
2322 .slice(indexOffset - centerOffset + 1 + evenCoef, indexOffset + centerOffset + 2)
2323 .addClass('slick-active')
2324 .attr('aria-hidden', 'false');
2325
2326 }
2327
2328 if (index === 0) {
2329
2330 allSlides
2331 .eq(allSlides.length - 1 - _.options.slidesToShow)
2332 .addClass('slick-center');
2333
2334 } else if (index === _.slideCount - 1) {
2335
2336 allSlides
2337 .eq(_.options.slidesToShow)
2338 .addClass('slick-center');
2339
2340 }
2341
2342 }
2343
2344 _.$slides
2345 .eq(index)
2346 .addClass('slick-center');
2347
2348 } else {
2349
2350 if (index >= 0 && index <= (_.slideCount - _.options.slidesToShow)) {
2351
2352 _.$slides
2353 .slice(index, index + _.options.slidesToShow)
2354 .addClass('slick-active')
2355 .attr('aria-hidden', 'false');
2356
2357 } else if (allSlides.length <= _.options.slidesToShow) {
2358
2359 allSlides
2360 .addClass('slick-active')
2361 .attr('aria-hidden', 'false');
2362
2363 } else {
2364
2365 remainder = _.slideCount % _.options.slidesToShow;
2366 indexOffset = _.options.infinite === true ? _.options.slidesToShow + index : index;
2367
2368 if (_.options.slidesToShow == _.options.slidesToScroll && (_.slideCount - index) < _.options.slidesToShow) {
2369
2370 allSlides
2371 .slice(indexOffset - (_.options.slidesToShow - remainder), indexOffset + remainder)
2372 .addClass('slick-active')
2373 .attr('aria-hidden', 'false');
2374
2375 } else {
2376
2377 allSlides
2378 .slice(indexOffset, indexOffset + _.options.slidesToShow)
2379 .addClass('slick-active')
2380 .attr('aria-hidden', 'false');
2381
2382 }
2383
2384 }
2385
2386 }
2387
2388 if (_.options.lazyLoad === 'ondemand' || _.options.lazyLoad === 'anticipated') {
2389 _.lazyLoad();
2390 }
2391 };
2392
2393 Slick.prototype.setupInfinite = function() {
2394
2395 var _ = this,
2396 i, slideIndex, infiniteCount;
2397
2398 if (_.options.fade === true) {
2399 _.options.centerMode = false;
2400 }
2401
2402 if (_.options.infinite === true && _.options.fade === false) {
2403
2404 slideIndex = null;
2405
2406 if (_.slideCount > _.options.slidesToShow) {
2407
2408 if (_.options.centerMode === true) {
2409 infiniteCount = _.options.slidesToShow + 1;
2410 } else {
2411 infiniteCount = _.options.slidesToShow;
2412 }
2413
2414 for (i = _.slideCount; i > (_.slideCount -
2415 infiniteCount); i -= 1) {
2416 slideIndex = i - 1;
2417 $(_.$slides[slideIndex]).clone(true).attr('id', '')
2418 .attr('data-slick-index', slideIndex - _.slideCount)
2419 .prependTo(_.$slideTrack).addClass('slick-cloned');
2420 }
2421 for (i = 0; i < infiniteCount + _.slideCount; i += 1) {
2422 slideIndex = i;
2423 $(_.$slides[slideIndex]).clone(true).attr('id', '')
2424 .attr('data-slick-index', slideIndex + _.slideCount)
2425 .appendTo(_.$slideTrack).addClass('slick-cloned');
2426 }
2427 _.$slideTrack.find('.slick-cloned').find('[id]').each(function() {
2428 $(this).attr('id', '');
2429 });
2430
2431 }
2432
2433 }
2434
2435 };
2436
2437 Slick.prototype.interrupt = function( toggle ) {
2438
2439 var _ = this;
2440
2441 if( !toggle ) {
2442 _.autoPlay();
2443 }
2444 _.interrupted = toggle;
2445
2446 };
2447
2448 Slick.prototype.selectHandler = function(event) {
2449
2450 var _ = this;
2451
2452 var targetElement =
2453 $(event.target).is('.slick-slide') ?
2454 $(event.target) :
2455 $(event.target).parents('.slick-slide');
2456
2457 var index = parseInt(targetElement.attr('data-slick-index'));
2458
2459 if (!index) index = 0;
2460
2461 if (_.slideCount <= _.options.slidesToShow) {
2462
2463 _.slideHandler(index, false, true);
2464 return;
2465
2466 }
2467
2468 _.slideHandler(index);
2469
2470 };
2471
2472 Slick.prototype.slideHandler = function(index, sync, dontAnimate) {
2473
2474 var targetSlide, animSlide, oldSlide, slideLeft, targetLeft = null,
2475 _ = this, navTarget;
2476
2477 sync = sync || false;
2478
2479 if (_.animating === true && _.options.waitForAnimate === true) {
2480 return;
2481 }
2482
2483 if (_.options.fade === true && _.currentSlide === index) {
2484 return;
2485 }
2486
2487 if (sync === false) {
2488 _.asNavFor(index);
2489 }
2490
2491 targetSlide = index;
2492 targetLeft = _.getLeft(targetSlide);
2493 slideLeft = _.getLeft(_.currentSlide);
2494
2495 _.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;
2496
2497 if (_.options.infinite === false && _.options.centerMode === false && (index < 0 || index > _.getDotCount() * _.options.slidesToScroll)) {
2498 if (_.options.fade === false) {
2499 targetSlide = _.currentSlide;
2500 if (dontAnimate !== true && _.slideCount > _.options.slidesToShow) {
2501 _.animateSlide(slideLeft, function() {
2502 _.postSlide(targetSlide);
2503 });
2504 } else {
2505 _.postSlide(targetSlide);
2506 }
2507 }
2508 return;
2509 } else if (_.options.infinite === false && _.options.centerMode === true && (index < 0 || index > (_.slideCount - _.options.slidesToScroll))) {
2510 if (_.options.fade === false) {
2511 targetSlide = _.currentSlide;
2512 if (dontAnimate !== true && _.slideCount > _.options.slidesToShow) {
2513 _.animateSlide(slideLeft, function() {
2514 _.postSlide(targetSlide);
2515 });
2516 } else {
2517 _.postSlide(targetSlide);
2518 }
2519 }
2520 return;
2521 }
2522
2523 if ( _.options.autoplay ) {
2524 clearInterval(_.autoPlayTimer);
2525 }
2526
2527 if (targetSlide < 0) {
2528 if (_.slideCount % _.options.slidesToScroll !== 0) {
2529 animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll);
2530 } else {
2531 animSlide = _.slideCount + targetSlide;
2532 }
2533 } else if (targetSlide >= _.slideCount) {
2534 if (_.slideCount % _.options.slidesToScroll !== 0) {
2535 animSlide = 0;
2536 } else {
2537 animSlide = targetSlide - _.slideCount;
2538 }
2539 } else {
2540 animSlide = targetSlide;
2541 }
2542
2543 _.animating = true;
2544
2545 _.$slider.trigger('beforeChange', [_, _.currentSlide, animSlide]);
2546
2547 oldSlide = _.currentSlide;
2548 _.currentSlide = animSlide;
2549
2550 _.setSlideClasses(_.currentSlide);
2551
2552 if ( _.options.asNavFor ) {
2553
2554 navTarget = _.getNavTarget();
2555 navTarget = navTarget.slick('getSlick');
2556
2557 if ( navTarget.slideCount <= navTarget.options.slidesToShow ) {
2558 navTarget.setSlideClasses(_.currentSlide);
2559 }
2560
2561 }
2562
2563 _.updateDots();
2564 _.updateArrows();
2565
2566 if (_.options.fade === true) {
2567 if (dontAnimate !== true) {
2568
2569 _.fadeSlideOut(oldSlide);
2570
2571 _.fadeSlide(animSlide, function() {
2572 _.postSlide(animSlide);
2573 });
2574
2575 } else {
2576 _.postSlide(animSlide);
2577 }
2578 _.animateHeight();
2579 return;
2580 }
2581
2582 if (dontAnimate !== true && _.slideCount > _.options.slidesToShow) {
2583 _.animateSlide(targetLeft, function() {
2584 _.postSlide(animSlide);
2585 });
2586 } else {
2587 _.postSlide(animSlide);
2588 }
2589
2590 };
2591
2592 Slick.prototype.startLoad = function() {
2593
2594 var _ = this;
2595
2596 if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
2597
2598 _.$prevArrow.hide();
2599 _.$nextArrow.hide();
2600
2601 }
2602
2603 if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
2604
2605 _.$dots.hide();
2606
2607 }
2608
2609 _.$slider.addClass('slick-loading');
2610
2611 };
2612
2613 Slick.prototype.swipeDirection = function() {
2614
2615 var xDist, yDist, r, swipeAngle, _ = this;
2616
2617 xDist = _.touchObject.startX - _.touchObject.curX;
2618 yDist = _.touchObject.startY - _.touchObject.curY;
2619 r = Math.atan2(yDist, xDist);
2620
2621 swipeAngle = Math.round(r * 180 / Math.PI);
2622 if (swipeAngle < 0) {
2623 swipeAngle = 360 - Math.abs(swipeAngle);
2624 }
2625
2626 if ((swipeAngle <= 45) && (swipeAngle >= 0)) {
2627 return (_.options.rtl === false ? 'left' : 'right');
2628 }
2629 if ((swipeAngle <= 360) && (swipeAngle >= 315)) {
2630 return (_.options.rtl === false ? 'left' : 'right');
2631 }
2632 if ((swipeAngle >= 135) && (swipeAngle <= 225)) {
2633 return (_.options.rtl === false ? 'right' : 'left');
2634 }
2635 if (_.options.verticalSwiping === true) {
2636 if ((swipeAngle >= 35) && (swipeAngle <= 135)) {
2637 return 'down';
2638 } else {
2639 return 'up';
2640 }
2641 }
2642
2643 return 'vertical';
2644
2645 };
2646
2647 Slick.prototype.swipeEnd = function(event) {
2648
2649 var _ = this,
2650 slideCount,
2651 direction;
2652
2653 _.dragging = false;
2654 _.swiping = false;
2655
2656 if (_.scrolling) {
2657 _.scrolling = false;
2658 return false;
2659 }
2660
2661 _.interrupted = false;
2662 _.shouldClick = ( _.touchObject.swipeLength > 10 ) ? false : true;
2663
2664 if ( _.touchObject.curX === undefined ) {
2665 return false;
2666 }
2667
2668 if ( _.touchObject.edgeHit === true ) {
2669 _.$slider.trigger('edge', [_, _.swipeDirection() ]);
2670 }
2671
2672 if ( _.touchObject.swipeLength >= _.touchObject.minSwipe ) {
2673
2674 direction = _.swipeDirection();
2675
2676 switch ( direction ) {
2677
2678 case 'left':
2679 case 'down':
2680
2681 slideCount =
2682 _.options.swipeToSlide ?
2683 _.checkNavigable( _.currentSlide + _.getSlideCount() ) :
2684 _.currentSlide + _.getSlideCount();
2685
2686 _.currentDirection = 0;
2687
2688 break;
2689
2690 case 'right':
2691 case 'up':
2692
2693 slideCount =
2694 _.options.swipeToSlide ?
2695 _.checkNavigable( _.currentSlide - _.getSlideCount() ) :
2696 _.currentSlide - _.getSlideCount();
2697
2698 _.currentDirection = 1;
2699
2700 break;
2701
2702 default:
2703
2704
2705 }
2706
2707 if( direction != 'vertical' ) {
2708
2709 _.slideHandler( slideCount );
2710 _.touchObject = {};
2711 _.$slider.trigger('swipe', [_, direction ]);
2712
2713 }
2714
2715 } else {
2716
2717 if ( _.touchObject.startX !== _.touchObject.curX ) {
2718
2719 _.slideHandler( _.currentSlide );
2720 _.touchObject = {};
2721
2722 }
2723
2724 }
2725
2726 };
2727
2728 Slick.prototype.swipeHandler = function(event) {
2729
2730 var _ = this;
2731
2732 if ((_.options.swipe === false) || ('ontouchend' in document && _.options.swipe === false)) {
2733 return;
2734 } else if (_.options.draggable === false && event.type.indexOf('mouse') !== -1) {
2735 return;
2736 }
2737
2738 _.touchObject.fingerCount = event.originalEvent && event.originalEvent.touches !== undefined ?
2739 event.originalEvent.touches.length : 1;
2740
2741 _.touchObject.minSwipe = _.listWidth / _.options
2742 .touchThreshold;
2743
2744 if (_.options.verticalSwiping === true) {
2745 _.touchObject.minSwipe = _.listHeight / _.options
2746 .touchThreshold;
2747 }
2748
2749 switch (event.data.action) {
2750
2751 case 'start':
2752 _.swipeStart(event);
2753 break;
2754
2755 case 'move':
2756 _.swipeMove(event);
2757 break;
2758
2759 case 'end':
2760 _.swipeEnd(event);
2761 break;
2762
2763 }
2764
2765 };
2766
2767 Slick.prototype.swipeMove = function(event) {
2768
2769 var _ = this,
2770 edgeWasHit = false,
2771 curLeft, swipeDirection, swipeLength, positionOffset, touches, verticalSwipeLength;
2772
2773 touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;
2774
2775 if (!_.dragging || _.scrolling || touches && touches.length !== 1) {
2776 return false;
2777 }
2778
2779 curLeft = _.getLeft(_.currentSlide);
2780
2781 _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;
2782 _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;
2783
2784 _.touchObject.swipeLength = Math.round(Math.sqrt(
2785 Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));
2786
2787 verticalSwipeLength = Math.round(Math.sqrt(
2788 Math.pow(_.touchObject.curY - _.touchObject.startY, 2)));
2789
2790 if (!_.options.verticalSwiping && !_.swiping && verticalSwipeLength > 4) {
2791 _.scrolling = true;
2792 return false;
2793 }
2794
2795 if (_.options.verticalSwiping === true) {
2796 _.touchObject.swipeLength = verticalSwipeLength;
2797 }
2798
2799 swipeDirection = _.swipeDirection();
2800
2801 if (event.originalEvent !== undefined && _.touchObject.swipeLength > 4) {
2802 _.swiping = true;
2803 event.preventDefault();
2804 }
2805
2806 positionOffset = (_.options.rtl === false ? 1 : -1) * (_.touchObject.curX > _.touchObject.startX ? 1 : -1);
2807 if (_.options.verticalSwiping === true) {
2808 positionOffset = _.touchObject.curY > _.touchObject.startY ? 1 : -1;
2809 }
2810
2811
2812 swipeLength = _.touchObject.swipeLength;
2813
2814 _.touchObject.edgeHit = false;
2815
2816 if (_.options.infinite === false) {
2817 if ((_.currentSlide === 0 && swipeDirection === 'right') || (_.currentSlide >= _.getDotCount() && swipeDirection === 'left')) {
2818 swipeLength = _.touchObject.swipeLength * _.options.edgeFriction;
2819 _.touchObject.edgeHit = true;
2820 }
2821 }
2822
2823 if (_.options.vertical === false) {
2824 _.swipeLeft = curLeft + swipeLength * positionOffset;
2825 } else {
2826 _.swipeLeft = curLeft + (swipeLength * (_.$list.height() / _.listWidth)) * positionOffset;
2827 }
2828 if (_.options.verticalSwiping === true) {
2829 _.swipeLeft = curLeft + swipeLength * positionOffset;
2830 }
2831
2832 if (_.options.fade === true || _.options.touchMove === false) {
2833 return false;
2834 }
2835
2836 if (_.animating === true) {
2837 _.swipeLeft = null;
2838 return false;
2839 }
2840
2841 _.setCSS(_.swipeLeft);
2842
2843 };
2844
2845 Slick.prototype.swipeStart = function(event) {
2846
2847 var _ = this,
2848 touches;
2849
2850 _.interrupted = true;
2851
2852 if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {
2853 _.touchObject = {};
2854 return false;
2855 }
2856
2857 if (event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {
2858 touches = event.originalEvent.touches[0];
2859 }
2860
2861 _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;
2862 _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;
2863
2864 _.dragging = true;
2865
2866 };
2867
2868 Slick.prototype.unfilterSlides = Slick.prototype.slickUnfilter = function() {
2869
2870 var _ = this;
2871
2872 if (_.$slidesCache !== null) {
2873
2874 _.unload();
2875
2876 _.$slideTrack.children(this.options.slide).detach();
2877
2878 _.$slidesCache.appendTo(_.$slideTrack);
2879
2880 _.reinit();
2881
2882 }
2883
2884 };
2885
2886 Slick.prototype.unload = function() {
2887
2888 var _ = this;
2889
2890 $('.slick-cloned', _.$slider).remove();
2891
2892 if (_.$dots) {
2893 _.$dots.remove();
2894 }
2895
2896 if (_.$prevArrow && _.htmlExpr.test(_.options.prevArrow)) {
2897 _.$prevArrow.remove();
2898 }
2899
2900 if (_.$nextArrow && _.htmlExpr.test(_.options.nextArrow)) {
2901 _.$nextArrow.remove();
2902 }
2903
2904 _.$slides
2905 .removeClass('slick-slide slick-active slick-visible slick-current')
2906 .attr('aria-hidden', 'true')
2907 .css('width', '');
2908
2909 };
2910
2911 Slick.prototype.unslick = function(fromBreakpoint) {
2912
2913 var _ = this;
2914 _.$slider.trigger('unslick', [_, fromBreakpoint]);
2915 _.destroy();
2916
2917 };
2918
2919 Slick.prototype.updateArrows = function() {
2920
2921 var _ = this,
2922 centerOffset;
2923
2924 centerOffset = Math.floor(_.options.slidesToShow / 2);
2925
2926 if ( _.options.arrows === true &&
2927 _.slideCount > _.options.slidesToShow &&
2928 !_.options.infinite ) {
2929
2930 _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2931 _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2932
2933 if (_.currentSlide === 0) {
2934
2935 _.$prevArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
2936 _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2937
2938 } else if (_.currentSlide >= _.slideCount - _.options.slidesToShow && _.options.centerMode === false) {
2939
2940 _.$nextArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
2941 _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2942
2943 } else if (_.currentSlide >= _.slideCount - 1 && _.options.centerMode === true) {
2944
2945 _.$nextArrow.addClass('slick-disabled').attr('aria-disabled', 'true');
2946 _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');
2947
2948 }
2949
2950 }
2951
2952 };
2953
2954 Slick.prototype.updateDots = function() {
2955
2956 var _ = this;
2957
2958 if (_.$dots !== null) {
2959
2960 _.$dots
2961 .find('li')
2962 .removeClass('slick-active')
2963 .end();
2964
2965 _.$dots
2966 .find('li')
2967 .eq(Math.floor(_.currentSlide / _.options.slidesToScroll))
2968 .addClass('slick-active');
2969
2970 }
2971
2972 };
2973
2974 Slick.prototype.visibility = function() {
2975
2976 var _ = this;
2977
2978 if ( _.options.autoplay ) {
2979
2980 if ( document[_.hidden] ) {
2981
2982 _.interrupted = true;
2983
2984 } else {
2985
2986 _.interrupted = false;
2987
2988 }
2989
2990 }
2991
2992 };
2993
2994 $.fn.slick = function() {
2995 var _ = this,
2996 opt = arguments[0],
2997 args = Array.prototype.slice.call(arguments, 1),
2998 l = _.length,
2999 i,
3000 ret;
3001 for (i = 0; i < l; i++) {
3002 if (typeof opt == 'object' || typeof opt == 'undefined')
3003 _[i].slick = new Slick(_[i], opt);
3004 else
3005 ret = _[i].slick[opt].apply(_[i].slick, args);
3006 if (typeof ret != 'undefined') return ret;
3007 }
3008 return _;
3009 };
3010
3011}));
Note: See TracBrowser for help on using the repository browser.