jquery-slick-rails 1.3.6 → 1.3.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (6) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +17 -1
  3. data/lib/jquery-slick-rails/version.rb +1 -1
  4. data/vendor/assets/javascripts/jquery.slick.js +1351 -1222
  5. data/vendor/assets/stylesheets/slick.css +17 -10
  6. metadata +3 -3
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: ddde7fd91d3d24bff24ad33987771d60b0f74593
4
- data.tar.gz: 5747b56eb8f7ad2178f3ee10ebca3f5e976d5d08
3
+ metadata.gz: 9555d9863b00347bbbfd4df4bd07eadefcb81823
4
+ data.tar.gz: 064c1bf51457ca7515d4515e8fa8d27143bd9a89
5
5
  SHA512:
6
- metadata.gz: b1099bb646c9c039fe927e9d13c6534be25621d36a46d295a71f897309d21a90a78bf1eaa726e7e148a3979a491a603637263b7cd13453d87e2192981d92431b
7
- data.tar.gz: 6436c0c0cb29c748fbc4c62c315e635b608ccd21573430e7885a9d43ef314a89e2ebea97a16d9556b7c95c894d5aa7bdb5c7e41c6116f23dd0566a1173001bb7
6
+ metadata.gz: f99d97538b03f3ec94c0b07d2aad66dfdde314692c8ef0ce0f9f3543393ead7334ddb77276adad11161e4017cd581d53e52902df4bebe56082978b29bf6f5c74
7
+ data.tar.gz: cac4de35e7b199b7dec8044546a62dd3d994441dbeb0f603481fa5d9c30978def35e5115c723d6f8eda58788edf1d52ed959e4c2d01b3dbf8c000b8823ecb44a
data/README.md CHANGED
@@ -1,5 +1,7 @@
1
1
  # JquerySlickRails
2
2
 
3
+ [![Gem Version](https://badge.fury.io/rb/jquery-slick-rails.svg)](http://badge.fury.io/rb/jquery-slick-rails)
4
+
3
5
  A ruby gem that uses the Rails asset pipeline to include the jQuery Slick plugin by Ken Wheeler
4
6
  (https://kenwheeler.github.io/slick/).
5
7
 
@@ -31,4 +33,18 @@ and this line
31
33
 
32
34
  @import 'slick';
33
35
 
34
- into your `application.css.scss`.
36
+ into your `application.css.scss`.
37
+
38
+ ## Contributing
39
+
40
+ 1. Fork it
41
+ 2. Create your feature branch (`git checkout -b my-new-feature`)
42
+ 3. Commit your changes (`git commit -am 'Added some feature'`)
43
+ 4. Push to the branch (`git push origin my-new-feature`)
44
+ 5. Create new Pull Request
45
+
46
+ ## License
47
+
48
+ This plugin is licensed under the [MIT License](https://github.com/bodrovis/jquery-slick-rails/blob/master/LICENSE.txt).
49
+
50
+ Copyright (c) 2014 [Ilya Bodrov](http://radiant-wind.com)
data/lib/jquery-slick-rails/version.rb CHANGED
@@ -1,3 +1,3 @@
1
1
  module JquerySlickRails
2
- VERSION = "1.3.6"
2
+ VERSION = "1.3.7"
3
3
  end
data/vendor/assets/javascripts/jquery.slick.js CHANGED
@@ -1,1703 +1,1832 @@
1
1
  /*
2
- _ _ _ _
2
+ _ _ _ _
3
3
  ___| (_) ___| | __ (_)___
4
- / __| | |/ __| |/ / | / __|
5
- \__ \ | | (__| < _ | \__ \
6
- |___/_|_|\___|_|\_(_)/ |___/
7
- |__/
4
+ / __| | |/ __| |/ / | / __|
5
+ \__ \ | | (__| < _ | \__ \
6
+ |___/_|_|\___|_|\_(_)/ |___/
7
+ |__/
8
8
 
9
- Version: 1.3.6
10
- Author: Ken Wheeler
9
+ Version: 1.3.7
10
+ Author: Ken Wheeler
11
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
12
+ Docs: http://kenwheeler.github.io/slick
13
+ Repo: http://github.com/kenwheeler/slick
14
+ Issues: http://github.com/kenwheeler/slick/issues
15
15
 
16
16
  */
17
17
 
18
18
  /* global window, document, define, jQuery, setInterval, clearInterval */
19
19
 
20
20
  (function(factory) {
21
- 'use strict';
22
- if (typeof define === 'function' && define.amd) {
23
- define(['jquery'], factory);
24
- } else {
25
- factory(jQuery);
26
- }
21
+ 'use strict';
22
+ if (typeof define === 'function' && define.amd) {
23
+ define(['jquery'], factory);
24
+ } else {
25
+ factory(jQuery);
26
+ }
27
27
 
28
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,
39
- responsiveSettings, breakpoint;
40
-
41
- _.defaults = {
42
- accessibility: true,
43
- arrows: true,
44
- autoplay: false,
45
- autoplaySpeed: 3000,
46
- centerMode: false,
47
- centerPadding: '50px',
48
- cssEase: 'ease',
49
- customPaging: function(slider, i) {
50
- return '<button type="button">' + (i + 1) + '</button>';
51
- },
52
- dots: false,
53
- draggable: true,
54
- easing: 'linear',
55
- fade: false,
56
- infinite: true,
57
- lazyLoad: 'ondemand',
58
- onBeforeChange: null,
59
- onAfterChange: null,
60
- onInit: null,
61
- onReInit: null,
62
- pauseOnHover: true,
63
- responsive: null,
64
- slide: 'div',
65
- slidesToShow: 1,
66
- slidesToScroll: 1,
67
- speed: 300,
68
- swipe: true,
69
- touchMove: true,
70
- touchThreshold: 5,
71
- useCSS: true,
72
- vertical: false
73
- };
74
-
75
- _.initials = {
76
- animating: false,
77
- autoPlayTimer: null,
78
- currentSlide: 0,
79
- currentLeft: null,
80
- direction: 1,
81
- $dots: null,
82
- listWidth: null,
83
- listHeight: null,
84
- loadIndex: 0,
85
- $nextArrow: null,
86
- $prevArrow: null,
87
- slideCount: null,
88
- slideWidth: null,
89
- $slideTrack: null,
90
- $slides: null,
91
- sliding: false,
92
- slideOffset: 0,
93
- swipeLeft: null,
94
- $list: null,
95
- touchObject: {},
96
- transformsEnabled: false
97
- };
98
-
99
- $.extend(_, _.initials);
100
-
101
- _.activeBreakpoint = null;
102
- _.animType = null;
103
- _.animProp = null;
104
- _.breakpoints = [];
105
- _.breakpointSettings = [];
106
- _.cssTransitions = false;
107
- _.paused = false;
108
- _.positionProp = null;
109
- _.$slider = $(element);
110
- _.$slidesCache = null;
111
- _.transformType = null;
112
- _.transitionType = null;
113
- _.windowWidth = 0;
114
- _.windowTimer = null;
115
-
116
- _.options = $.extend({}, _.defaults, settings);
117
-
118
- _.originalSettings = _.options;
119
- responsiveSettings = _.options.responsive || null;
120
-
121
- if (responsiveSettings && responsiveSettings.length > -1) {
122
- for (breakpoint in responsiveSettings) {
123
- if (responsiveSettings.hasOwnProperty(breakpoint)) {
124
- _.breakpoints.push(responsiveSettings[
125
- breakpoint].breakpoint);
126
- _.breakpointSettings[responsiveSettings[
127
- breakpoint].breakpoint] =
128
- responsiveSettings[breakpoint].settings;
129
- }
130
- }
131
- _.breakpoints.sort(function(a, b) {
132
- return b - a;
133
- });
134
- }
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,
39
+ responsiveSettings, breakpoint;
40
+
41
+ _.defaults = {
42
+ accessibility: true,
43
+ appendArrows: $(element),
44
+ arrows: true,
45
+ asNavFor: null,
46
+ prevArrow: '<button type="button" data-role="none" class="slick-prev">Previous</button>',
47
+ nextArrow: '<button type="button" data-role="none" class="slick-next">Next</button>',
48
+ autoplay: false,
49
+ autoplaySpeed: 3000,
50
+ centerMode: false,
51
+ centerPadding: '50px',
52
+ cssEase: 'ease',
53
+ customPaging: function(slider, i) {
54
+ return '<button type="button" data-role="none">' + (i + 1) + '</button>';
55
+ },
56
+ dots: false,
57
+ dotsClass: 'slick-dots',
58
+ draggable: true,
59
+ easing: 'linear',
60
+ fade: false,
61
+ focusOnSelect: false,
62
+ infinite: true,
63
+ lazyLoad: 'ondemand',
64
+ onBeforeChange: null,
65
+ onAfterChange: null,
66
+ onInit: null,
67
+ onReInit: null,
68
+ pauseOnHover: true,
69
+ pauseOnDotsHover: false,
70
+ responsive: null,
71
+ rtl: false,
72
+ slide: 'div',
73
+ slidesToShow: 1,
74
+ slidesToScroll: 1,
75
+ speed: 300,
76
+ swipe: true,
77
+ touchMove: true,
78
+ touchThreshold: 5,
79
+ useCSS: true,
80
+ vertical: false
81
+ };
82
+
83
+ _.initials = {
84
+ animating: false,
85
+ dragging: false,
86
+ autoPlayTimer: null,
87
+ currentSlide: 0,
88
+ currentLeft: null,
89
+ direction: 1,
90
+ $dots: null,
91
+ listWidth: null,
92
+ listHeight: null,
93
+ loadIndex: 0,
94
+ $nextArrow: null,
95
+ $prevArrow: null,
96
+ slideCount: null,
97
+ slideWidth: null,
98
+ $slideTrack: null,
99
+ $slides: null,
100
+ sliding: false,
101
+ slideOffset: 0,
102
+ swipeLeft: null,
103
+ $list: null,
104
+ touchObject: {},
105
+ transformsEnabled: false
106
+ };
107
+
108
+ $.extend(_, _.initials);
109
+
110
+ _.activeBreakpoint = null;
111
+ _.animType = null;
112
+ _.animProp = null;
113
+ _.breakpoints = [];
114
+ _.breakpointSettings = [];
115
+ _.cssTransitions = false;
116
+ _.paused = false;
117
+ _.positionProp = null;
118
+ _.$slider = $(element);
119
+ _.$slidesCache = null;
120
+ _.transformType = null;
121
+ _.transitionType = null;
122
+ _.windowWidth = 0;
123
+ _.windowTimer = null;
124
+
125
+ _.options = $.extend({}, _.defaults, settings);
126
+
127
+ _.originalSettings = _.options;
128
+ responsiveSettings = _.options.responsive || null;
129
+
130
+ if (responsiveSettings && responsiveSettings.length > -1) {
131
+ for (breakpoint in responsiveSettings) {
132
+ if (responsiveSettings.hasOwnProperty(breakpoint)) {
133
+ _.breakpoints.push(responsiveSettings[
134
+ breakpoint].breakpoint);
135
+ _.breakpointSettings[responsiveSettings[
136
+ breakpoint].breakpoint] =
137
+ responsiveSettings[breakpoint].settings;
138
+ }
139
+ }
140
+ _.breakpoints.sort(function(a, b) {
141
+ return b - a;
142
+ });
143
+ }
135
144
 
136
- _.autoPlay = $.proxy(_.autoPlay, _);
137
- _.autoPlayClear = $.proxy(_.autoPlayClear, _);
138
- _.changeSlide = $.proxy(_.changeSlide, _);
139
- _.setPosition = $.proxy(_.setPosition, _);
140
- _.swipeHandler = $.proxy(_.swipeHandler, _);
141
- _.dragHandler = $.proxy(_.dragHandler, _);
142
- _.keyHandler = $.proxy(_.keyHandler, _);
143
- _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);
145
+ _.autoPlay = $.proxy(_.autoPlay, _);
146
+ _.autoPlayClear = $.proxy(_.autoPlayClear, _);
147
+ _.changeSlide = $.proxy(_.changeSlide, _);
148
+ _.selectHandler = $.proxy(_.selectHandler, _);
149
+ _.setPosition = $.proxy(_.setPosition, _);
150
+ _.swipeHandler = $.proxy(_.swipeHandler, _);
151
+ _.dragHandler = $.proxy(_.dragHandler, _);
152
+ _.keyHandler = $.proxy(_.keyHandler, _);
153
+ _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);
144
154
 
145
- _.instanceUid = instanceUid++;
155
+ _.instanceUid = instanceUid++;
146
156
 
147
- _.init();
157
+ // A simple way to check for HTML strings
158
+ // Strict HTML recognition (must start with <)
159
+ // Extracted from jQuery v1.11 source
160
+ _.htmlExpr = /^(?:\s*(<[\w\W]+>)[^>]*)$/;
148
161
 
149
- }
162
+ _.init();
150
163
 
151
- return Slick;
164
+ }
152
165
 
153
- }());
166
+ return Slick;
154
167
 
155
- Slick.prototype.addSlide = function(markup, index, addBefore) {
168
+ }());
156
169
 
157
- var _ = this;
170
+ Slick.prototype.addSlide = function(markup, index, addBefore) {
158
171
 
159
- if (typeof(index) === 'boolean') {
160
- addBefore = index;
161
- index = null;
162
- } else if (index < 0 || (index >= _.slideCount)) {
163
- return false;
164
- }
172
+ var _ = this;
165
173
 
166
- _.unload();
174
+ if (typeof(index) === 'boolean') {
175
+ addBefore = index;
176
+ index = null;
177
+ } else if (index < 0 || (index >= _.slideCount)) {
178
+ return false;
179
+ }
167
180
 
168
- if (typeof(index) === 'number') {
169
- if (index === 0 && _.$slides.length === 0) {
170
- $(markup).appendTo(_.$slideTrack);
171
- } else if (addBefore) {
172
- $(markup).insertBefore(_.$slides.eq(index));
173
- } else {
174
- $(markup).insertAfter(_.$slides.eq(index));
175
- }
176
- } else {
177
- if (addBefore === true) {
178
- $(markup).prependTo(_.$slideTrack);
179
- } else {
180
- $(markup).appendTo(_.$slideTrack);
181
- }
182
- }
181
+ _.unload();
182
+
183
+ if (typeof(index) === 'number') {
184
+ if (index === 0 && _.$slides.length === 0) {
185
+ $(markup).appendTo(_.$slideTrack);
186
+ } else if (addBefore) {
187
+ $(markup).insertBefore(_.$slides.eq(index));
188
+ } else {
189
+ $(markup).insertAfter(_.$slides.eq(index));
190
+ }
191
+ } else {
192
+ if (addBefore === true) {
193
+ $(markup).prependTo(_.$slideTrack);
194
+ } else {
195
+ $(markup).appendTo(_.$slideTrack);
196
+ }
197
+ }
183
198
 
184
- _.$slides = _.$slideTrack.children(this.options.slide);
199
+ _.$slides = _.$slideTrack.children(this.options.slide);
185
200
 
186
- _.$slideTrack.children(this.options.slide).remove();
201
+ _.$slideTrack.children(this.options.slide).detach();
187
202
 
188
- _.$slideTrack.append(_.$slides);
203
+ _.$slideTrack.append(_.$slides);
189
204
 
190
- _.$slidesCache = _.$slides;
205
+ _.$slides.each(function(index, element) {
206
+ $(element).attr("index",index);
207
+ });
191
208
 
192
- _.reinit();
209
+ _.$slidesCache = _.$slides;
193
210
 
194
- };
211
+ _.reinit();
195
212
 
196
- Slick.prototype.animateSlide = function(targetLeft,
197
- callback) {
213
+ };
198
214
 
199
- var animProps = {}, _ = this;
215
+ Slick.prototype.animateSlide = function(targetLeft, callback) {
216
+
217
+ var animProps = {}, _ = this;
218
+
219
+ if (_.options.rtl === true && _.options.vertical === false) {
220
+ targetLeft = -targetLeft;
221
+ }
222
+ if (_.transformsEnabled === false) {
223
+ if (_.options.vertical === false) {
224
+ _.$slideTrack.animate({
225
+ left: targetLeft
226
+ }, _.options.speed, _.options.easing, callback);
227
+ } else {
228
+ _.$slideTrack.animate({
229
+ top: targetLeft
230
+ }, _.options.speed, _.options.easing, callback);
231
+ }
232
+
233
+ } else {
200
234
 
201
- if (_.transformsEnabled === false) {
235
+ if (_.cssTransitions === false) {
236
+
237
+ $({
238
+ animStart: _.currentLeft
239
+ }).animate({
240
+ animStart: targetLeft
241
+ }, {
242
+ duration: _.options.speed,
243
+ easing: _.options.easing,
244
+ step: function(now) {
202
245
  if (_.options.vertical === false) {
203
- _.$slideTrack.animate({
204
- left: targetLeft
205
- }, _.options.speed, _.options.easing, callback);
246
+ animProps[_.animType] = 'translate(' +
247
+ now + 'px, 0px)';
248
+ _.$slideTrack.css(animProps);
206
249
  } else {
207
- _.$slideTrack.animate({
208
- top: targetLeft
209
- }, _.options.speed, _.options.easing, callback);
250
+ animProps[_.animType] = 'translate(0px,' +
251
+ now + 'px)';
252
+ _.$slideTrack.css(animProps);
253
+ }
254
+ },
255
+ complete: function() {
256
+ if (callback) {
257
+ callback.call();
210
258
  }
259
+ }
260
+ });
211
261
 
212
- } else {
262
+ } else {
213
263
 
214
- if (_.cssTransitions === false) {
215
-
216
- $({
217
- animStart: _.currentLeft
218
- }).animate({
219
- animStart: targetLeft
220
- }, {
221
- duration: _.options.speed,
222
- easing: _.options.easing,
223
- step: function(now) {
224
- if (_.options.vertical === false) {
225
- animProps[_.animType] = 'translate(' +
226
- now + 'px, 0px)';
227
- _.$slideTrack.css(animProps);
228
- } else {
229
- animProps[_.animType] = 'translate(0px,' +
230
- now + 'px)';
231
- _.$slideTrack.css(animProps);
232
- }
233
- },
234
- complete: function() {
235
- if (callback) {
236
- callback.call();
237
- }
238
- }
239
- });
264
+ _.applyTransition();
240
265
 
241
- } else {
266
+ if (_.options.vertical === false) {
267
+ animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';
268
+ } else {
269
+ animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';
270
+ }
271
+ _.$slideTrack.css(animProps);
242
272
 
243
- _.applyTransition();
273
+ if (callback) {
274
+ setTimeout(function() {
244
275
 
245
- if (_.options.vertical === false) {
246
- animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';
247
- } else {
248
- animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';
249
- }
250
- _.$slideTrack.css(animProps);
276
+ _.disableTransition();
251
277
 
252
- if (callback) {
253
- setTimeout(function() {
278
+ callback.call();
279
+ }, _.options.speed);
280
+ }
254
281
 
255
- _.disableTransition();
282
+ }
256
283
 
257
- callback.call();
258
- }, _.options.speed);
259
- }
284
+ }
260
285
 
261
- }
286
+ };
262
287
 
263
- }
288
+ Slick.prototype.applyTransition = function(slide) {
264
289
 
265
- };
290
+ var _ = this,
291
+ transition = {};
266
292
 
267
- Slick.prototype.applyTransition = function(slide) {
293
+ if (_.options.fade === false) {
294
+ transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;
295
+ } else {
296
+ transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
297
+ }
268
298
 
269
- var _ = this,
270
- transition = {};
299
+ if (_.options.fade === false) {
300
+ _.$slideTrack.css(transition);
301
+ } else {
302
+ _.$slides.eq(slide).css(transition);
303
+ }
271
304
 
272
- if (_.options.fade === false) {
273
- transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;
274
- } else {
275
- transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;
276
- }
305
+ };
277
306
 
278
- if (_.options.fade === false) {
279
- _.$slideTrack.css(transition);
280
- } else {
281
- _.$slides.eq(slide).css(transition);
282
- }
307
+ Slick.prototype.autoPlay = function() {
283
308
 
284
- };
309
+ var _ = this;
285
310
 
286
- Slick.prototype.autoPlay = function() {
311
+ if (_.autoPlayTimer) {
312
+ clearInterval(_.autoPlayTimer);
313
+ }
287
314
 
288
- var _ = this;
315
+ if (_.slideCount > _.options.slidesToShow && _.paused !== true) {
316
+ _.autoPlayTimer = setInterval(_.autoPlayIterator,
317
+ _.options.autoplaySpeed);
318
+ }
289
319
 
290
- if (_.autoPlayTimer) {
291
- clearInterval(_.autoPlayTimer);
292
- }
320
+ };
293
321
 
294
- if (_.slideCount > _.options.slidesToShow && _.paused !== true) {
295
- _.autoPlayTimer = setInterval(_.autoPlayIterator,
296
- _.options.autoplaySpeed);
297
- }
322
+ Slick.prototype.autoPlayClear = function() {
298
323
 
299
- };
324
+ var _ = this;
300
325
 
301
- Slick.prototype.autoPlayClear = function() {
326
+ if (_.autoPlayTimer) {
327
+ clearInterval(_.autoPlayTimer);
328
+ }
302
329
 
303
- var _ = this;
330
+ };
304
331
 
305
- if (_.autoPlayTimer) {
306
- clearInterval(_.autoPlayTimer);
307
- }
332
+ Slick.prototype.autoPlayIterator = function() {
308
333
 
309
- };
334
+ var _ = this;
335
+ var asNavFor = _.options.asNavFor != null ? $(_.options.asNavFor).getSlick() : null;
310
336
 
311
- Slick.prototype.autoPlayIterator = function() {
337
+ if (_.options.infinite === false) {
312
338
 
313
- var _ = this;
339
+ if (_.direction === 1) {
314
340
 
315
- if (_.options.infinite === false) {
341
+ if ((_.currentSlide + 1) === _.slideCount -
342
+ 1) {
343
+ _.direction = 0;
344
+ }
316
345
 
317
- if (_.direction === 1) {
346
+ _.slideHandler(_.currentSlide + _.options.slidesToScroll);
347
+ if(asNavFor != null) asNavFor.slideHandler(asNavFor.currentSlide + asNavFor.options.slidesToScroll);
318
348
 
319
- if ((_.currentSlide + 1) === _.slideCount -
320
- 1) {
321
- _.direction = 0;
322
- }
349
+ } else {
323
350
 
324
- _.slideHandler(_.currentSlide + _.options
325
- .slidesToScroll);
351
+ if ((_.currentSlide - 1 === 0)) {
326
352
 
327
- } else {
353
+ _.direction = 1;
328
354
 
329
- if ((_.currentSlide - 1 === 0)) {
355
+ }
330
356
 
331
- _.direction = 1;
357
+ _.slideHandler(_.currentSlide - _.options.slidesToScroll);
358
+ if(asNavFor != null) asNavFor.slideHandler(asNavFor.currentSlide - asNavFor.options.slidesToScroll);
332
359
 
333
- }
360
+ }
334
361
 
335
- _.slideHandler(_.currentSlide - _.options
336
- .slidesToScroll);
362
+ } else {
337
363
 
338
- }
364
+ _.slideHandler(_.currentSlide + _.options.slidesToScroll);
365
+ if(asNavFor != null) asNavFor.slideHandler(asNavFor.currentSlide + asNavFor.options.slidesToScroll);
339
366
 
340
- } else {
367
+ }
341
368
 
342
- _.slideHandler(_.currentSlide + _.options.slidesToScroll);
369
+ };
343
370
 
344
- }
371
+ Slick.prototype.buildArrows = function() {
345
372
 
346
- };
373
+ var _ = this;
347
374
 
348
- Slick.prototype.buildArrows = function() {
375
+ if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
349
376
 
350
- var _ = this;
377
+ _.$prevArrow = $(_.options.prevArrow);
378
+ _.$nextArrow = $(_.options.nextArrow);
351
379
 
352
- if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
380
+ if (_.htmlExpr.test(_.options.prevArrow)) {
381
+ _.$prevArrow.appendTo(_.options.appendArrows);
382
+ }
353
383
 
354
- _.$prevArrow = $(
355
- '<button type="button" class="slick-prev">Previous</button>').appendTo(
356
- _.$slider);
357
- _.$nextArrow = $(
358
- '<button type="button" class="slick-next">Next</button>').appendTo(
359
- _.$slider);
384
+ if (_.htmlExpr.test(_.options.nextArrow)) {
385
+ _.$nextArrow.appendTo(_.options.appendArrows);
386
+ }
360
387
 
361
- if (_.options.infinite !== true) {
362
- _.$prevArrow.addClass('slick-disabled');
363
- }
388
+ if (_.options.infinite !== true) {
389
+ _.$prevArrow.addClass('slick-disabled');
390
+ }
364
391
 
365
- }
392
+ }
366
393
 
367
- };
394
+ };
368
395
 
369
- Slick.prototype.buildDots = function() {
396
+ Slick.prototype.buildDots = function() {
370
397
 
371
- var _ = this,
372
- i, dotString;
398
+ var _ = this,
399
+ i, dotString;
373
400
 
374
- if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
401
+ if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
375
402
 
376
- dotString = '<ul class="slick-dots">';
403
+ dotString = '<ul class="' + _.options.dotsClass + '">';
377
404
 
378
- for (i = 0; i <= _.getDotCount(); i += 1) {
379
- dotString += '<li>' + _.options.customPaging.call(this, _, i) + '</li>';
380
- }
405
+ for (i = 0; i <= _.getDotCount(); i += 1) {
406
+ dotString += '<li>' + _.options.customPaging.call(this, _, i) + '</li>';
407
+ }
381
408
 
382
- dotString += '</ul>';
409
+ dotString += '</ul>';
383
410
 
384
- _.$dots = $(dotString).appendTo(
385
- _.$slider);
411
+ _.$dots = $(dotString).appendTo(
412
+ _.$slider);
386
413
 
387
- _.$dots.find('li').first().addClass(
388
- 'slick-active');
414
+ _.$dots.find('li').first().addClass(
415
+ 'slick-active');
389
416
 
390
- }
417
+ }
391
418
 
392
- };
419
+ };
393
420
 
394
- Slick.prototype.buildOut = function() {
421
+ Slick.prototype.buildOut = function() {
395
422
 
396
- var _ = this;
423
+ var _ = this;
397
424
 
398
- _.$slides = _.$slider.children(_.options.slide +
425
+ _.$slides = _.$slider.children(_.options.slide +
399
426
  ':not(.slick-cloned)').addClass(
400
427
  'slick-slide');
401
- _.slideCount = _.$slides.length;
402
- _.$slidesCache = _.$slides;
428
+ _.slideCount = _.$slides.length;
403
429
 
404
- _.$slider.addClass('slick-slider');
430
+ _.$slides.each(function(index, element) {
431
+ $(element).attr("index",index);
432
+ });
405
433
 
406
- _.$slideTrack = (_.slideCount === 0) ?
407
- $('<div class="slick-track"/>').appendTo(_.$slider) :
408
- _.$slides.wrapAll('<div class="slick-track"/>').parent();
434
+ _.$slidesCache = _.$slides;
409
435
 
410
- _.$list = _.$slideTrack.wrap(
411
- '<div class="slick-list"/>').parent();
412
- _.$slideTrack.css('opacity', 0);
436
+ _.$slider.addClass('slick-slider');
413
437
 
414
- if (_.options.centerMode === true) {
415
- _.options.infinite = true;
416
- _.options.slidesToScroll = 1;
417
- if (_.options.slidesToShow % 2 === 0) {
418
- _.options.slidesToShow = 3;
419
- }
420
- }
438
+ _.$slideTrack = (_.slideCount === 0) ?
439
+ $('<div class="slick-track"/>').appendTo(_.$slider) :
440
+ _.$slides.wrapAll('<div class="slick-track"/>').parent();
421
441
 
422
- $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');
442
+ _.$list = _.$slideTrack.wrap(
443
+ '<div class="slick-list"/>').parent();
444
+ _.$slideTrack.css('opacity', 0);
423
445
 
424
- _.setupInfinite();
446
+ if (_.options.centerMode === true) {
447
+ _.options.slidesToScroll = 1;
448
+ if (_.options.slidesToShow % 2 === 0) {
449
+ _.options.slidesToShow = 3;
450
+ }
451
+ }
425
452
 
426
- _.buildArrows();
453
+ $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');
427
454
 
428
- _.buildDots();
455
+ _.setupInfinite();
429
456
 
430
- if (_.options.accessibility === true) {
431
- _.$list.prop('tabIndex', 0);
432
- }
457
+ _.buildArrows();
433
458
 
434
- _.setSlideClasses(typeof this.currentSlide === 'number' ? this.currentSlide : 0);
459
+ _.buildDots();
435
460
 
436
- if (_.options.draggable === true) {
437
- _.$list.addClass('draggable');
438
- }
461
+ _.updateDots();
439
462
 
440
- };
463
+ if (_.options.accessibility === true) {
464
+ _.$list.prop('tabIndex', 0);
465
+ }
441
466
 
442
- Slick.prototype.checkResponsive = function() {
467
+ _.setSlideClasses(typeof this.currentSlide === 'number' ? this.currentSlide : 0);
443
468
 
444
- var _ = this,
445
- breakpoint, targetBreakpoint;
469
+ if (_.options.draggable === true) {
470
+ _.$list.addClass('draggable');
471
+ }
446
472
 
447
- if (_.originalSettings.responsive && _.originalSettings
448
- .responsive.length > -1 && _.originalSettings.responsive !== null) {
473
+ };
449
474
 
450
- targetBreakpoint = null;
475
+ Slick.prototype.checkResponsive = function() {
451
476
 
452
- for (breakpoint in _.breakpoints) {
453
- if (_.breakpoints.hasOwnProperty(breakpoint)) {
454
- if ($(window).width() < _.breakpoints[
455
- breakpoint]) {
456
- targetBreakpoint = _.breakpoints[
457
- breakpoint];
458
- }
459
- }
460
- }
477
+ var _ = this,
478
+ breakpoint, targetBreakpoint;
461
479
 
462
- if (targetBreakpoint !== null) {
463
- if (_.activeBreakpoint !== null) {
464
- if (targetBreakpoint !== _.activeBreakpoint) {
465
- _.activeBreakpoint =
466
- targetBreakpoint;
467
- _.options = $.extend({}, _.defaults,
468
- _.breakpointSettings[
469
- targetBreakpoint]);
470
- _.refresh();
471
- }
472
- } else {
473
- _.activeBreakpoint = targetBreakpoint;
474
- _.options = $.extend({}, _.defaults,
475
- _.breakpointSettings[
476
- targetBreakpoint]);
477
- _.refresh();
478
- }
479
- } else {
480
- if (_.activeBreakpoint !== null) {
481
- _.activeBreakpoint = null;
482
- _.options = $.extend({}, _.defaults,
483
- _.originalSettings);
484
- _.refresh();
485
- }
486
- }
480
+ if (_.originalSettings.responsive && _.originalSettings
481
+ .responsive.length > -1 && _.originalSettings.responsive !== null) {
482
+
483
+ targetBreakpoint = null;
487
484
 
485
+ for (breakpoint in _.breakpoints) {
486
+ if (_.breakpoints.hasOwnProperty(breakpoint)) {
487
+ if ($(window).width() < _.breakpoints[
488
+ breakpoint]) {
489
+ targetBreakpoint = _.breakpoints[
490
+ breakpoint];
491
+ }
488
492
  }
493
+ }
489
494
 
490
- };
495
+ if (targetBreakpoint !== null) {
496
+ if (_.activeBreakpoint !== null) {
497
+ if (targetBreakpoint !== _.activeBreakpoint) {
498
+ _.activeBreakpoint =
499
+ targetBreakpoint;
500
+ _.options = $.extend({}, _.options,
501
+ _.breakpointSettings[
502
+ targetBreakpoint]);
503
+ _.refresh();
504
+ }
505
+ } else {
506
+ _.activeBreakpoint = targetBreakpoint;
507
+ _.options = $.extend({}, _.options,
508
+ _.breakpointSettings[
509
+ targetBreakpoint]);
510
+ _.refresh();
511
+ }
512
+ } else {
513
+ if (_.activeBreakpoint !== null) {
514
+ _.activeBreakpoint = null;
515
+ _.options = $.extend({}, _.options,
516
+ _.originalSettings);
517
+ _.refresh();
518
+ }
519
+ }
520
+
521
+ }
491
522
 
492
- Slick.prototype.changeSlide = function(event) {
523
+ };
493
524
 
494
- var _ = this;
525
+ Slick.prototype.changeSlide = function(event) {
495
526
 
496
- switch (event.data.message) {
527
+ var _ = this,
528
+ $target = $(event.target);
529
+ var asNavFor = _.options.asNavFor != null ? $(_.options.asNavFor).getSlick() : null;
497
530
 
498
- case 'previous':
499
- _.slideHandler(_.currentSlide - _.options
500
- .slidesToScroll);
501
- break;
531
+ // If target is a link, prevent default action.
532
+ $target.is('a') && event.preventDefault();
502
533
 
503
- case 'next':
504
- _.slideHandler(_.currentSlide + _.options
505
- .slidesToScroll);
506
- break;
534
+ switch (event.data.message) {
507
535
 
508
- case 'index':
509
- _.slideHandler($(event.target).parent().index() * _.options.slidesToScroll);
510
- break;
536
+ case 'previous':
537
+ if (_.slideCount > _.options.slidesToShow) {
538
+ _.slideHandler(_.currentSlide - _.options
539
+ .slidesToScroll);
540
+ if(asNavFor != null) asNavFor.slideHandler(asNavFor.currentSlide - asNavFor.options.slidesToScroll);
541
+ }
542
+ break;
511
543
 
512
- default:
513
- return false;
544
+ case 'next':
545
+ if (_.slideCount > _.options.slidesToShow) {
546
+ _.slideHandler(_.currentSlide + _.options
547
+ .slidesToScroll);
548
+ if(asNavFor != null) asNavFor.slideHandler(asNavFor.currentSlide + asNavFor.options.slidesToScroll);
514
549
  }
550
+ break;
515
551
 
516
- };
552
+ case 'index':
553
+ var index = $(event.target).parent().index() * _.options.slidesToScroll;
554
+ _.slideHandler(index);
555
+ if(asNavFor != null) asNavFor.slideHandler(index); break;
517
556
 
518
- Slick.prototype.destroy = function() {
557
+ default:
558
+ return false;
559
+ }
519
560
 
520
- var _ = this;
561
+ };
521
562
 
522
- _.autoPlayClear();
563
+ Slick.prototype.destroy = function() {
523
564
 
524
- _.touchObject = {};
565
+ var _ = this;
525
566
 
526
- $('.slick-cloned', _.$slider).remove();
527
- if (_.$dots) {
528
- _.$dots.remove();
529
- }
530
- if (_.$prevArrow) {
531
- _.$prevArrow.remove();
532
- _.$nextArrow.remove();
533
- }
534
- _.$slides.unwrap().unwrap();
535
- _.$slides.removeClass(
536
- 'slick-slide slick-active slick-visible').removeAttr('style');
537
- _.$slider.removeClass('slick-slider');
538
- _.$slider.removeClass('slick-initialized');
567
+ _.autoPlayClear();
539
568
 
540
- _.$list.off('.slick');
541
- $(window).off('.slick-' + _.instanceUid);
542
- };
569
+ _.touchObject = {};
543
570
 
544
- Slick.prototype.disableTransition = function(slide) {
571
+ $('.slick-cloned', _.$slider).remove();
572
+ if (_.$dots) {
573
+ _.$dots.remove();
574
+ }
575
+ if (_.$prevArrow) {
576
+ _.$prevArrow.remove();
577
+ _.$nextArrow.remove();
578
+ }
579
+ if (_.$slides.parent().hasClass('slick-track')) {
580
+ _.$slides.unwrap().unwrap();
581
+ }
582
+ _.$slides.removeClass(
583
+ 'slick-slide slick-active slick-visible').removeAttr('style');
584
+ _.$slider.removeClass('slick-slider');
585
+ _.$slider.removeClass('slick-initialized');
545
586
 
546
- var _ = this,
547
- transition = {};
587
+ _.$list.off('.slick');
588
+ $(window).off('.slick-' + _.instanceUid);
589
+ $(document).off('.slick-' + _.instanceUid);
548
590
 
549
- transition[_.transitionType] = "";
591
+ };
550
592
 
551
- if (_.options.fade === false) {
552
- _.$slideTrack.css(transition);
553
- } else {
554
- _.$slides.eq(slide).css(transition);
555
- }
593
+ Slick.prototype.disableTransition = function(slide) {
556
594
 
557
- };
595
+ var _ = this,
596
+ transition = {};
558
597
 
559
- Slick.prototype.fadeSlide = function(slideIndex, callback) {
598
+ transition[_.transitionType] = "";
560
599
 
561
- var _ = this;
600
+ if (_.options.fade === false) {
601
+ _.$slideTrack.css(transition);
602
+ } else {
603
+ _.$slides.eq(slide).css(transition);
604
+ }
562
605
 
563
- if (_.cssTransitions === false) {
606
+ };
564
607
 
565
- _.$slides.eq(slideIndex).css({
566
- zIndex: 1000
567
- });
608
+ Slick.prototype.fadeSlide = function(slideIndex, callback) {
568
609
 
569
- _.$slides.eq(slideIndex).animate({
570
- opacity: 1
571
- }, _.options.speed, _.options.easing, callback);
610
+ var _ = this;
572
611
 
573
- } else {
612
+ if (_.cssTransitions === false) {
574
613
 
575
- _.applyTransition(slideIndex);
614
+ _.$slides.eq(slideIndex).css({
615
+ zIndex: 1000
616
+ });
576
617
 
577
- _.$slides.eq(slideIndex).css({
578
- opacity: 1,
579
- zIndex: 1000
580
- });
618
+ _.$slides.eq(slideIndex).animate({
619
+ opacity: 1
620
+ }, _.options.speed, _.options.easing, callback);
581
621
 
582
- if (callback) {
583
- setTimeout(function() {
622
+ } else {
584
623
 
585
- _.disableTransition(slideIndex);
624
+ _.applyTransition(slideIndex);
586
625
 
587
- callback.call();
588
- }, _.options.speed);
589
- }
626
+ _.$slides.eq(slideIndex).css({
627
+ opacity: 1,
628
+ zIndex: 1000
629
+ });
590
630
 
591
- }
631
+ if (callback) {
632
+ setTimeout(function() {
592
633
 
593
- };
634
+ _.disableTransition(slideIndex);
594
635
 
595
- Slick.prototype.filterSlides = function(filter) {
636
+ callback.call();
637
+ }, _.options.speed);
638
+ }
596
639
 
597
- var _ = this;
640
+ }
598
641
 
599
- if (filter !== null) {
642
+ };
600
643
 
601
- _.unload();
644
+ Slick.prototype.filterSlides = function(filter) {
602
645
 
603
- _.$slideTrack.children(this.options.slide).remove();
646
+ var _ = this;
604
647
 
605
- _.$slidesCache.filter(filter).appendTo(_.$slideTrack);
648
+ if (filter !== null) {
606
649
 
607
- _.reinit();
650
+ _.unload();
608
651
 
609
- }
652
+ _.$slideTrack.children(this.options.slide).detach();
610
653
 
611
- };
654
+ _.$slidesCache.filter(filter).appendTo(_.$slideTrack);
612
655
 
613
- Slick.prototype.getCurrent = function() {
656
+ _.reinit();
614
657
 
615
- var _ = this;
658
+ }
616
659
 
617
- return _.currentSlide;
660
+ };
618
661
 
619
- };
662
+ Slick.prototype.getCurrent = function() {
620
663
 
621
- Slick.prototype.getDotCount = function() {
664
+ var _ = this;
622
665
 
623
- var _ = this,
624
- breaker = 0,
625
- dotCounter = 0,
626
- dotCount = 0,
627
- dotLimit;
666
+ return _.currentSlide;
628
667
 
629
- dotLimit = _.options.infinite === true ? _.slideCount + _.options.slidesToShow - _.options.slidesToScroll : _.slideCount;
668
+ };
630
669
 
631
- while (breaker < dotLimit) {
632
- dotCount++;
633
- dotCounter += _.options.slidesToScroll;
634
- breaker = dotCounter + _.options.slidesToShow;
635
- }
670
+ Slick.prototype.getDotCount = function() {
636
671
 
637
- return dotCount;
672
+ var _ = this,
673
+ breaker = 0,
674
+ dotCounter = 0,
675
+ dotCount = 0,
676
+ dotLimit;
638
677
 
639
- };
678
+ dotLimit = _.options.infinite === true ? _.slideCount + _.options.slidesToShow - _.options.slidesToScroll : _.slideCount;
640
679
 
641
- Slick.prototype.getLeft = function(slideIndex) {
680
+ while (breaker < dotLimit) {
681
+ dotCount++;
682
+ dotCounter += _.options.slidesToScroll;
683
+ breaker = dotCounter + _.options.slidesToShow;
684
+ }
642
685
 
643
- var _ = this,
644
- targetLeft,
645
- verticalHeight,
646
- verticalOffset = 0;
686
+ return dotCount;
647
687
 
648
- _.slideOffset = 0;
649
- verticalHeight = _.$slides.first().outerHeight();
688
+ };
650
689
 
651
- if (_.options.infinite === true) {
652
- if (_.slideCount > _.options.slidesToShow) {
653
- _.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;
654
- verticalOffset = (verticalHeight * _.options.slidesToShow) * -1;
655
- }
656
- if (_.slideCount % _.options.slidesToScroll !== 0) {
657
- if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {
658
- _.slideOffset = ((_.slideCount % _.options.slidesToShow) * _.slideWidth) * -1;
659
- verticalOffset = ((_.slideCount % _.options.slidesToShow) * verticalHeight) * -1;
660
- }
661
- }
662
- } else {
663
- if (_.slideCount % _.options.slidesToShow !== 0) {
664
- if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {
665
- _.slideOffset = (_.options.slidesToShow * _.slideWidth) - ((_.slideCount % _.options.slidesToShow) * _.slideWidth);
666
- verticalOffset = ((_.slideCount % _.options.slidesToShow) * verticalHeight);
667
- }
668
- }
669
- }
690
+ Slick.prototype.getLeft = function(slideIndex) {
670
691
 
671
- if (_.options.centerMode === true) {
672
- _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;
673
- }
692
+ var _ = this,
693
+ targetLeft,
694
+ verticalHeight,
695
+ verticalOffset = 0;
674
696
 
675
- if (_.options.vertical === false) {
676
- targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;
677
- } else {
678
- targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;
697
+ _.slideOffset = 0;
698
+ verticalHeight = _.$slides.first().outerHeight();
699
+
700
+ if (_.options.infinite === true) {
701
+ if (_.slideCount > _.options.slidesToShow) {
702
+ _.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;
703
+ verticalOffset = (verticalHeight * _.options.slidesToShow) * -1;
704
+ }
705
+ if (_.slideCount % _.options.slidesToScroll !== 0) {
706
+ if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {
707
+ _.slideOffset = ((_.slideCount % _.options.slidesToShow) * _.slideWidth) * -1;
708
+ verticalOffset = ((_.slideCount % _.options.slidesToShow) * verticalHeight) * -1;
679
709
  }
710
+ }
711
+ } else {
712
+ if (_.slideCount % _.options.slidesToShow !== 0) {
713
+ if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {
714
+ _.slideOffset = (_.options.slidesToShow * _.slideWidth) - ((_.slideCount % _.options.slidesToShow) * _.slideWidth);
715
+ verticalOffset = ((_.slideCount % _.options.slidesToShow) * verticalHeight);
716
+ }
717
+ }
718
+ }
680
719
 
681
- return targetLeft;
720
+ if (_.options.centerMode === true && _.options.infinite === true) {
721
+ _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;
722
+ } else if (_.options.centerMode === true) {
723
+ _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);
724
+ }
682
725
 
683
- };
726
+ if (_.options.vertical === false) {
727
+ targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;
728
+ } else {
729
+ targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;
730
+ }
684
731
 
685
- Slick.prototype.init = function() {
732
+ return targetLeft;
686
733
 
687
- var _ = this;
734
+ };
688
735
 
689
- if (!$(_.$slider).hasClass('slick-initialized')) {
736
+ Slick.prototype.init = function() {
690
737
 
691
- $(_.$slider).addClass('slick-initialized');
692
- _.buildOut();
693
- _.setProps();
694
- _.startLoad();
695
- _.loadSlider();
696
- _.initializeEvents();
697
- _.checkResponsive();
698
- }
738
+ var _ = this;
699
739
 
700
- if (_.options.onInit !== null) {
701
- _.options.onInit.call(this, _);
702
- }
740
+ if (!$(_.$slider).hasClass('slick-initialized')) {
703
741
 
704
- };
742
+ $(_.$slider).addClass('slick-initialized');
743
+ _.buildOut();
744
+ _.setProps();
745
+ _.startLoad();
746
+ _.loadSlider();
747
+ _.initializeEvents();
748
+ _.checkResponsive();
749
+ }
705
750
 
706
- Slick.prototype.initArrowEvents = function() {
751
+ if (_.options.onInit !== null) {
752
+ _.options.onInit.call(this, _);
753
+ }
707
754
 
708
- var _ = this;
755
+ };
709
756
 
710
- if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
711
- _.$prevArrow.on('click.slick', {
712
- message: 'previous'
713
- }, _.changeSlide);
714
- _.$nextArrow.on('click.slick', {
715
- message: 'next'
716
- }, _.changeSlide);
717
- }
757
+ Slick.prototype.initArrowEvents = function() {
718
758
 
719
- };
759
+ var _ = this;
720
760
 
721
- Slick.prototype.initDotEvents = function() {
761
+ if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
762
+ _.$prevArrow.on('click.slick', {
763
+ message: 'previous'
764
+ }, _.changeSlide);
765
+ _.$nextArrow.on('click.slick', {
766
+ message: 'next'
767
+ }, _.changeSlide);
768
+ }
722
769
 
723
- var _ = this;
770
+ };
724
771
 
725
- if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
726
- $('li', _.$dots).on('click.slick', {
727
- message: 'index'
728
- }, _.changeSlide);
729
- }
772
+ Slick.prototype.initDotEvents = function() {
730
773
 
731
- };
774
+ var _ = this;
732
775
 
733
- Slick.prototype.initializeEvents = function() {
776
+ if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
777
+ $('li', _.$dots).on('click.slick', {
778
+ message: 'index'
779
+ }, _.changeSlide);
780
+ }
734
781
 
735
- var _ = this;
782
+ if (_.options.dots === true && _.options.pauseOnDotsHover === true && _.options.autoplay === true) {
783
+ $('li', _.$dots)
784
+ .on('mouseenter.slick', _.autoPlayClear)
785
+ .on('mouseleave.slick', _.autoPlay);
786
+ }
736
787
 
737
- _.initArrowEvents();
788
+ };
738
789
 
739
- _.initDotEvents();
790
+ Slick.prototype.initializeEvents = function() {
740
791
 
741
- _.$list.on('touchstart.slick mousedown.slick', {
742
- action: 'start'
743
- }, _.swipeHandler);
744
- _.$list.on('touchmove.slick mousemove.slick', {
745
- action: 'move'
746
- }, _.swipeHandler);
747
- _.$list.on('touchend.slick mouseup.slick', {
748
- action: 'end'
749
- }, _.swipeHandler);
750
- _.$list.on('touchcancel.slick mouseleave.slick', {
751
- action: 'end'
752
- }, _.swipeHandler);
792
+ var _ = this;
753
793
 
754
- if (_.options.pauseOnHover === true && _.options.autoplay === true) {
755
- _.$list.on('mouseenter.slick', _.autoPlayClear);
756
- _.$list.on('mouseleave.slick', _.autoPlay);
757
- }
794
+ _.initArrowEvents();
758
795
 
759
- if(_.options.accessibility === true) {
760
- _.$list.on('keydown.slick', _.keyHandler);
761
- }
796
+ _.initDotEvents();
762
797
 
763
- $(window).on('orientationchange.slick.slick-' + _.instanceUid, function() {
764
- _.checkResponsive();
765
- _.setPosition();
766
- });
798
+ _.$list.on('touchstart.slick mousedown.slick', {
799
+ action: 'start'
800
+ }, _.swipeHandler);
801
+ _.$list.on('touchmove.slick mousemove.slick', {
802
+ action: 'move'
803
+ }, _.swipeHandler);
804
+ _.$list.on('touchend.slick mouseup.slick', {
805
+ action: 'end'
806
+ }, _.swipeHandler);
807
+ _.$list.on('touchcancel.slick mouseleave.slick', {
808
+ action: 'end'
809
+ }, _.swipeHandler);
767
810
 
768
- $(window).on('resize.slick.slick-' + _.instanceUid, function() {
769
- if ($(window).width !== _.windowWidth) {
770
- clearTimeout(_.windowDelay);
771
- _.windowDelay = window.setTimeout(function() {
772
- _.windowWidth = $(window).width();
773
- _.checkResponsive();
774
- _.setPosition();
775
- }, 50);
776
- }
777
- });
811
+ if (_.options.pauseOnHover === true && _.options.autoplay === true) {
812
+ _.$list.on('mouseenter.slick', _.autoPlayClear);
813
+ _.$list.on('mouseleave.slick', _.autoPlay);
814
+ }
778
815
 
779
- $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);
780
- $(document).on('ready.slick.slick-' + _.instanceUid, _.setPosition);
816
+ if(_.options.accessibility === true) {
817
+ _.$list.on('keydown.slick', _.keyHandler);
818
+ }
781
819
 
782
- };
820
+ if(_.options.focusOnSelect === true) {
821
+ $(_.options.slide, _.$slideTrack).on('click.slick', _.selectHandler);
822
+ }
783
823
 
784
- Slick.prototype.initUI = function() {
824
+ $(window).on('orientationchange.slick.slick-' + _.instanceUid, function() {
825
+ _.checkResponsive();
826
+ _.setPosition();
827
+ });
785
828
 
786
- var _ = this;
829
+ $(window).on('resize.slick.slick-' + _.instanceUid, function() {
830
+ if ($(window).width() !== _.windowWidth) {
831
+ clearTimeout(_.windowDelay);
832
+ _.windowDelay = window.setTimeout(function() {
833
+ _.windowWidth = $(window).width();
834
+ _.checkResponsive();
835
+ _.setPosition();
836
+ }, 50);
837
+ }
838
+ });
787
839
 
788
- if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
840
+ $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);
841
+ $(document).on('ready.slick.slick-' + _.instanceUid, _.setPosition);
789
842
 
790
- _.$prevArrow.show();
791
- _.$nextArrow.show();
843
+ };
792
844
 
793
- }
845
+ Slick.prototype.initUI = function() {
794
846
 
795
- if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
847
+ var _ = this;
796
848
 
797
- _.$dots.show();
849
+ if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
798
850
 
799
- }
851
+ _.$prevArrow.show();
852
+ _.$nextArrow.show();
800
853
 
801
- if (_.options.autoplay === true) {
854
+ }
802
855
 
803
- _.autoPlay();
856
+ if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
804
857
 
805
- }
858
+ _.$dots.show();
806
859
 
807
- };
860
+ }
808
861
 
809
- Slick.prototype.keyHandler = function(event) {
862
+ if (_.options.autoplay === true) {
810
863
 
811
- var _ = this;
864
+ _.autoPlay();
812
865
 
813
- if (event.keyCode === 37) {
814
- _.changeSlide({
815
- data: {
816
- message: 'previous'
817
- }
818
- });
819
- } else if (event.keyCode === 39) {
820
- _.changeSlide({
821
- data: {
822
- message: 'next'
823
- }
824
- });
825
- }
866
+ }
826
867
 
827
- };
868
+ };
828
869
 
829
- Slick.prototype.lazyLoad = function() {
870
+ Slick.prototype.keyHandler = function(event) {
830
871
 
831
- var _ = this,
832
- loadRange, cloneRange, rangeStart, rangeEnd;
872
+ var _ = this;
833
873
 
834
- if (_.options.centerMode === true || _.options.fade === true ) {
835
- rangeStart = _.options.slidesToShow + _.currentSlide - 1;
836
- rangeEnd = rangeStart + _.options.slidesToShow + 2;
837
- } else {
838
- rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;
839
- rangeEnd = rangeStart + _.options.slidesToShow;
874
+ if (event.keyCode === 37) {
875
+ _.changeSlide({
876
+ data: {
877
+ message: 'previous'
840
878
  }
879
+ });
880
+ } else if (event.keyCode === 39) {
881
+ _.changeSlide({
882
+ data: {
883
+ message: 'next'
884
+ }
885
+ });
886
+ }
841
887
 
842
- loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);
843
-
844
- $('img[data-lazy]', loadRange).not('[src]').each(function() {
845
- $(this).css({opacity: 0}).attr('src', $(this).attr('data-lazy')).removeClass('slick-loading').load(function(){
846
- $(this).animate({ opacity: 1 }, 200);
847
- });
848
- });
888
+ };
849
889
 
850
- if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
851
- cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);
852
- $('img[data-lazy]', cloneRange).not('[src]').each(function() {
853
- $(this).css({opacity: 0}).attr('src', $(this).attr('data-lazy')).removeClass('slick-loading').load(function(){
854
- $(this).animate({ opacity: 1 }, 200);
855
- });
856
- });
857
- } else if (_.currentSlide === 0) {
858
- cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
859
- $('img[data-lazy]', cloneRange).not('[src]').each(function() {
860
- $(this).css({opacity: 0}).attr('src', $(this).attr('data-lazy')).removeClass('slick-loading').load(function(){
861
- $(this).animate({ opacity: 1 }, 200);
862
- });
863
- });
864
- }
890
+ Slick.prototype.lazyLoad = function() {
865
891
 
866
- };
892
+ var _ = this,
893
+ loadRange, cloneRange, rangeStart, rangeEnd;
867
894
 
868
- Slick.prototype.loadSlider = function() {
895
+ function loadImages(imagesScope) {
896
+ $('img[data-lazy]', imagesScope).each(function() {
897
+ var image = $(this),
898
+ imageSource = $(this).attr('data-lazy') + "?" + new Date().getTime();
869
899
 
870
- var _ = this;
900
+ image
901
+ .load(function() { image.animate({ opacity: 1 }, 200); })
902
+ .css({ opacity: 0 })
903
+ .attr('src', imageSource)
904
+ .removeAttr('data-lazy')
905
+ .removeClass('slick-loading');
906
+ });
907
+ }
871
908
 
872
- _.setPosition();
909
+ if (_.options.centerMode === true || _.options.fade === true ) {
910
+ rangeStart = _.options.slidesToShow + _.currentSlide - 1;
911
+ rangeEnd = rangeStart + _.options.slidesToShow + 2;
912
+ } else {
913
+ rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;
914
+ rangeEnd = rangeStart + _.options.slidesToShow;
915
+ }
873
916
 
874
- _.$slideTrack.css({
875
- opacity: 1
876
- });
917
+ loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);
918
+ loadImages(loadRange);
919
+
920
+ if (_.slideCount == 1){
921
+ cloneRange = _.$slider.find('.slick-slide')
922
+ loadImages(cloneRange)
923
+ }else
924
+ if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
925
+ cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);
926
+ loadImages(cloneRange)
927
+ } else if (_.currentSlide === 0) {
928
+ cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);
929
+ loadImages(cloneRange);
930
+ }
877
931
 
878
- _.$slider.removeClass('slick-loading');
932
+ };
879
933
 
880
- _.initUI();
934
+ Slick.prototype.loadSlider = function() {
881
935
 
882
- if (_.options.lazyLoad === 'progressive') {
883
- _.progressiveLazyLoad();
884
- }
936
+ var _ = this;
885
937
 
886
- };
938
+ _.setPosition();
887
939
 
888
- Slick.prototype.postSlide = function(index) {
940
+ _.$slideTrack.css({
941
+ opacity: 1
942
+ });
889
943
 
890
- var _ = this;
944
+ _.$slider.removeClass('slick-loading');
891
945
 
892
- if (_.options.onAfterChange !== null) {
893
- _.options.onAfterChange.call(this, _, index);
894
- }
946
+ _.initUI();
895
947
 
896
- _.animating = false;
948
+ if (_.options.lazyLoad === 'progressive') {
949
+ _.progressiveLazyLoad();
950
+ }
897
951
 
898
- _.setPosition();
952
+ };
899
953
 
900
- _.swipeLeft = null;
954
+ Slick.prototype.postSlide = function(index) {
901
955
 
902
- if (_.options.autoplay === true && _.paused === false) {
903
- _.autoPlay();
904
- }
956
+ var _ = this;
905
957
 
906
- };
958
+ if (_.options.onAfterChange !== null) {
959
+ _.options.onAfterChange.call(this, _, index);
960
+ }
907
961
 
908
- Slick.prototype.progressiveLazyLoad = function() {
962
+ _.animating = false;
909
963
 
910
- var _ = this,
911
- imgCount, targetImage;
964
+ _.setPosition();
912
965
 
913
- imgCount = $('img[data-lazy]').not('[src]').length;
966
+ _.swipeLeft = null;
914
967
 
915
- if (imgCount > 0) {
916
- targetImage = $($('img[data-lazy]', _.$slider).not('[src]').get(0));
917
- targetImage.attr('src', targetImage.attr('data-lazy')).removeClass('slick-loading').load(function() {
918
- _.progressiveLazyLoad();
919
- });
920
- }
968
+ if (_.options.autoplay === true && _.paused === false) {
969
+ _.autoPlay();
970
+ }
921
971
 
922
- };
972
+ };
923
973
 
924
- Slick.prototype.refresh = function() {
974
+ Slick.prototype.progressiveLazyLoad = function() {
925
975
 
926
- var _ = this,
927
- currentSlide = _.currentSlide;
976
+ var _ = this,
977
+ imgCount, targetImage;
928
978
 
929
- _.destroy();
979
+ imgCount = $('img[data-lazy]').length;
930
980
 
931
- $.extend(_, _.initials);
981
+ if (imgCount > 0) {
982
+ targetImage = $('img[data-lazy]', _.$slider).first();
983
+ targetImage.attr('src', targetImage.attr('data-lazy')).removeClass('slick-loading').load(function() {
984
+ targetImage.removeAttr('data-lazy');
985
+ _.progressiveLazyLoad();
986
+ });
987
+ }
932
988
 
933
- _.currentSlide = currentSlide;
934
- _.init();
989
+ };
935
990
 
936
- };
991
+ Slick.prototype.refresh = function() {
937
992
 
938
- Slick.prototype.reinit = function() {
993
+ var _ = this,
994
+ currentSlide = _.currentSlide;
939
995
 
940
- var _ = this;
996
+ _.destroy();
941
997
 
942
- _.$slides = _.$slideTrack.children(_.options.slide).addClass(
943
- 'slick-slide');
998
+ $.extend(_, _.initials);
944
999
 
945
- _.slideCount = _.$slides.length;
1000
+ _.currentSlide = currentSlide;
1001
+ _.init();
946
1002
 
947
- if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
948
- _.currentSlide = _.currentSlide - _.options.slidesToScroll;
949
- }
1003
+ };
950
1004
 
951
- _.setProps();
1005
+ Slick.prototype.reinit = function() {
952
1006
 
953
- _.setupInfinite();
1007
+ var _ = this;
954
1008
 
955
- _.buildArrows();
1009
+ _.$slides = _.$slideTrack.children(_.options.slide).addClass(
1010
+ 'slick-slide');
956
1011
 
957
- _.updateArrows();
1012
+ _.slideCount = _.$slides.length;
958
1013
 
959
- _.initArrowEvents();
1014
+ if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {
1015
+ _.currentSlide = _.currentSlide - _.options.slidesToScroll;
1016
+ }
960
1017
 
961
- _.buildDots();
1018
+ _.setProps();
962
1019
 
963
- _.updateDots();
1020
+ _.setupInfinite();
964
1021
 
965
- _.initDotEvents();
1022
+ _.buildArrows();
966
1023
 
967
- _.setSlideClasses(0);
1024
+ _.updateArrows();
968
1025
 
969
- _.setPosition();
1026
+ _.initArrowEvents();
970
1027
 
971
- if (_.options.onReInit !== null) {
972
- _.options.onReInit.call(this, _);
973
- }
1028
+ _.buildDots();
974
1029
 
975
- };
1030
+ _.updateDots();
976
1031
 
977
- Slick.prototype.removeSlide = function(index, removeBefore) {
1032
+ _.initDotEvents();
978
1033
 
979
- var _ = this;
1034
+ if(_.options.focusOnSelect === true) {
1035
+ $(_.options.slide, _.$slideTrack).on('click.slick', _.selectHandler);
1036
+ }
980
1037
 
981
- if (typeof(index) === 'boolean') {
982
- removeBefore = index;
983
- index = removeBefore === true ? 0 : _.slideCount - 1;
984
- } else {
985
- index = removeBefore === true ? --index : index;
986
- }
1038
+ _.setSlideClasses(0);
987
1039
 
988
- if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
989
- return false;
990
- }
1040
+ _.setPosition();
991
1041
 
992
- _.unload();
1042
+ if (_.options.onReInit !== null) {
1043
+ _.options.onReInit.call(this, _);
1044
+ }
993
1045
 
994
- _.$slideTrack.children(this.options.slide).eq(index).remove();
1046
+ };
995
1047
 
996
- _.$slides = _.$slideTrack.children(this.options.slide);
1048
+ Slick.prototype.removeSlide = function(index, removeBefore) {
997
1049
 
998
- _.$slideTrack.children(this.options.slide).remove();
1050
+ var _ = this;
999
1051
 
1000
- _.$slideTrack.append(_.$slides);
1052
+ if (typeof(index) === 'boolean') {
1053
+ removeBefore = index;
1054
+ index = removeBefore === true ? 0 : _.slideCount - 1;
1055
+ } else {
1056
+ index = removeBefore === true ? --index : index;
1057
+ }
1001
1058
 
1002
- _.$slidesCache = _.$slides;
1059
+ if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {
1060
+ return false;
1061
+ }
1003
1062
 
1004
- _.reinit();
1063
+ _.unload();
1005
1064
 
1006
- };
1065
+ _.$slideTrack.children(this.options.slide).eq(index).remove();
1007
1066
 
1008
- Slick.prototype.setCSS = function(position) {
1067
+ _.$slides = _.$slideTrack.children(this.options.slide);
1009
1068
 
1010
- var _ = this,
1011
- positionProps = {}, x, y;
1069
+ _.$slideTrack.children(this.options.slide).detach();
1012
1070
 
1013
- x = _.positionProp == 'left' ? position + 'px' : '0px';
1014
- y = _.positionProp == 'top' ? position + 'px' : '0px';
1071
+ _.$slideTrack.append(_.$slides);
1015
1072
 
1016
- positionProps[_.positionProp] = position;
1073
+ _.$slidesCache = _.$slides;
1017
1074
 
1018
- if (_.transformsEnabled === false) {
1019
- _.$slideTrack.css(positionProps);
1020
- } else {
1021
- positionProps = {};
1022
- if (_.cssTransitions === false) {
1023
- positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';
1024
- _.$slideTrack.css(positionProps);
1025
- } else {
1026
- positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';
1027
- _.$slideTrack.css(positionProps);
1028
- }
1029
- }
1075
+ _.reinit();
1030
1076
 
1031
- };
1077
+ };
1032
1078
 
1033
- Slick.prototype.setDimensions = function() {
1079
+ Slick.prototype.setCSS = function(position) {
1034
1080
 
1035
- var _ = this;
1081
+ var _ = this,
1082
+ positionProps = {}, x, y;
1036
1083
 
1037
- if (_.options.centerMode === true) {
1038
- _.$slideTrack.children('.slick-slide').width(_.slideWidth);
1039
- } else {
1040
- _.$slideTrack.children('.slick-slide').width(_.slideWidth);
1041
- }
1084
+ if (_.options.rtl === true) {
1085
+ position = -position;
1086
+ }
1087
+ x = _.positionProp == 'left' ? position + 'px' : '0px';
1088
+ y = _.positionProp == 'top' ? position + 'px' : '0px';
1042
1089
 
1090
+ positionProps[_.positionProp] = position;
1043
1091
 
1044
- if (_.options.vertical === false) {
1045
- _.$slideTrack.width(Math.ceil((_.slideWidth * _
1046
- .$slideTrack.children('.slick-slide').length)));
1047
- if (_.options.centerMode === true) {
1048
- _.$list.css({
1049
- padding: ('0px ' + _.options.centerPadding)
1050
- });
1051
- }
1052
- } else {
1053
- _.$list.height(_.$slides.first().outerHeight() * _.options.slidesToShow);
1054
- _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight() * _
1055
- .$slideTrack.children('.slick-slide').length)));
1056
- if (_.options.centerMode === true) {
1057
- _.$list.css({
1058
- padding: (_.options.centerPadding + ' 0px')
1059
- });
1060
- }
1061
- }
1092
+ if (_.transformsEnabled === false) {
1093
+ _.$slideTrack.css(positionProps);
1094
+ } else {
1095
+ positionProps = {};
1096
+ if (_.cssTransitions === false) {
1097
+ positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';
1098
+ _.$slideTrack.css(positionProps);
1099
+ } else {
1100
+ positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';
1101
+ _.$slideTrack.css(positionProps);
1102
+ }
1103
+ }
1062
1104
 
1063
- };
1105
+ };
1064
1106
 
1065
- Slick.prototype.setFade = function() {
1107
+ Slick.prototype.setDimensions = function() {
1066
1108
 
1067
- var _ = this,
1068
- targetLeft;
1109
+ var _ = this;
1069
1110
 
1070
- _.$slides.each(function(index, element) {
1071
- targetLeft = (_.slideWidth * index) * -1;
1072
- $(element).css({
1073
- position: 'relative',
1074
- left: targetLeft,
1075
- top: 0,
1076
- zIndex: 800,
1077
- opacity: 0
1078
- });
1111
+ if (_.options.vertical === false) {
1112
+ if (_.options.centerMode === true) {
1113
+ _.$list.css({
1114
+ padding: ('0px ' + _.options.centerPadding)
1079
1115
  });
1080
-
1081
- _.$slides.eq(_.currentSlide).css({
1082
- zIndex: 900,
1083
- opacity: 1
1116
+ }
1117
+ } else {
1118
+ _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);
1119
+ if (_.options.centerMode === true) {
1120
+ _.$list.css({
1121
+ padding: (_.options.centerPadding + ' 0px')
1084
1122
  });
1123
+ }
1124
+ }
1085
1125
 
1086
- };
1126
+ _.listWidth = _.$list.width();
1127
+ _.listHeight = _.$list.height();
1087
1128
 
1088
- Slick.prototype.setPosition = function() {
1089
1129
 
1090
- var _ = this;
1130
+ if(_.options.vertical === false) {
1131
+ _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);
1132
+ _.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));
1091
1133
 
1092
- _.setValues();
1093
- _.setDimensions();
1134
+ } else {
1135
+ _.slideWidth = Math.ceil(_.listWidth);
1136
+ _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));
1094
1137
 
1095
- if (_.options.fade === false) {
1096
- _.setCSS(_.getLeft(_.currentSlide));
1097
- } else {
1098
- _.setFade();
1099
- }
1138
+ }
1100
1139
 
1101
- };
1140
+ var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();
1141
+ _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);
1102
1142
 
1103
- Slick.prototype.setProps = function() {
1143
+ };
1104
1144
 
1105
- var _ = this;
1145
+ Slick.prototype.setFade = function() {
1106
1146
 
1107
- _.positionProp = _.options.vertical === true ? 'top' : 'left';
1147
+ var _ = this,
1148
+ targetLeft;
1108
1149
 
1109
- if (_.positionProp === 'top') {
1110
- _.$slider.addClass('slick-vertical');
1111
- } else {
1112
- _.$slider.removeClass('slick-vertical');
1113
- }
1150
+ _.$slides.each(function(index, element) {
1151
+ targetLeft = (_.slideWidth * index) * -1;
1152
+ $(element).css({
1153
+ position: 'relative',
1154
+ left: targetLeft,
1155
+ top: 0,
1156
+ zIndex: 800,
1157
+ opacity: 0
1158
+ });
1159
+ });
1114
1160
 
1115
- if (document.body.style.WebkitTransition !== undefined ||
1116
- document.body.style.MozTransition !== undefined ||
1117
- document.body.style.msTransition !== undefined) {
1118
- if(_.options.useCSS === true) {
1119
- _.cssTransitions = true;
1120
- }
1121
- }
1161
+ _.$slides.eq(_.currentSlide).css({
1162
+ zIndex: 900,
1163
+ opacity: 1
1164
+ });
1122
1165
 
1123
- if (document.body.style.MozTransform !== undefined) {
1124
- _.animType = 'MozTransform';
1125
- _.transformType = "-moz-transform";
1126
- _.transitionType = 'MozTransition';
1127
- }
1128
- if (document.body.style.webkitTransform !== undefined) {
1129
- _.animType = 'webkitTransform';
1130
- _.transformType = "-webkit-transform";
1131
- _.transitionType = 'webkitTransition';
1132
- }
1133
- if (document.body.style.msTransform !== undefined) {
1134
- _.animType = 'transform';
1135
- _.transformType = "transform";
1136
- _.transitionType = 'transition';
1137
- }
1166
+ };
1138
1167
 
1139
- _.transformsEnabled = (_.animType !== null);
1168
+ Slick.prototype.setPosition = function() {
1140
1169
 
1141
- };
1170
+ var _ = this;
1142
1171
 
1143
- Slick.prototype.setValues = function() {
1172
+ _.setDimensions();
1144
1173
 
1145
- var _ = this;
1174
+ if (_.options.fade === false) {
1175
+ _.setCSS(_.getLeft(_.currentSlide));
1176
+ } else {
1177
+ _.setFade();
1178
+ }
1146
1179
 
1147
- _.listWidth = _.$list.width();
1148
- _.listHeight = _.$list.height();
1149
- if(_.options.vertical === false) {
1150
- _.slideWidth = Math.ceil(_.listWidth / _.options
1151
- .slidesToShow);
1152
- } else {
1153
- _.slideWidth = Math.ceil(_.listWidth);
1154
- }
1180
+ };
1155
1181
 
1156
- };
1182
+ Slick.prototype.setProps = function() {
1157
1183
 
1158
- Slick.prototype.setSlideClasses = function(index) {
1184
+ var _ = this;
1159
1185
 
1160
- var _ = this,
1161
- centerOffset, allSlides, indexOffset;
1186
+ _.positionProp = _.options.vertical === true ? 'top' : 'left';
1162
1187
 
1163
- _.$slider.find('.slick-slide').removeClass('slick-active').removeClass('slick-center');
1164
- allSlides = _.$slider.find('.slick-slide');
1188
+ if (_.positionProp === 'top') {
1189
+ _.$slider.addClass('slick-vertical');
1190
+ } else {
1191
+ _.$slider.removeClass('slick-vertical');
1192
+ }
1165
1193
 
1166
- if (_.options.centerMode === true) {
1194
+ if (document.body.style.WebkitTransition !== undefined ||
1195
+ document.body.style.MozTransition !== undefined ||
1196
+ document.body.style.msTransition !== undefined) {
1197
+ if(_.options.useCSS === true) {
1198
+ _.cssTransitions = true;
1199
+ }
1200
+ }
1167
1201
 
1168
- centerOffset = Math.floor(_.options.slidesToShow / 2);
1202
+ if (document.body.style.MozTransform !== undefined) {
1203
+ _.animType = 'MozTransform';
1204
+ _.transformType = "-moz-transform";
1205
+ _.transitionType = 'MozTransition';
1206
+ }
1207
+ if (document.body.style.webkitTransform !== undefined) {
1208
+ _.animType = 'webkitTransform';
1209
+ _.transformType = "-webkit-transform";
1210
+ _.transitionType = 'webkitTransition';
1211
+ }
1212
+ if (document.body.style.msTransform !== undefined) {
1213
+ _.animType = 'msTransform';
1214
+ _.transformType = "-ms-transform";
1215
+ _.transitionType = 'msTransition';
1216
+ }
1217
+ if (document.body.style.transform !== undefined) {
1218
+ _.animType = 'transform';
1219
+ _.transformType = "transform";
1220
+ _.transitionType = 'transition';
1221
+ }
1169
1222
 
1170
- if (index >= centerOffset && index <= (_.slideCount - 1) - centerOffset) {
1171
- _.$slides.slice(index - centerOffset, index + centerOffset + 1).addClass('slick-active');
1172
- } else {
1173
- indexOffset = _.options.slidesToShow + index;
1174
- allSlides.slice(indexOffset - centerOffset + 1, indexOffset + centerOffset + 2).addClass('slick-active');
1175
- }
1223
+ _.transformsEnabled = (_.animType !== null);
1176
1224
 
1177
- if (index === 0) {
1178
- allSlides.eq(allSlides.length - 1 - _.options.slidesToShow).addClass('slick-center');
1179
- } else if (index === _.slideCount - 1) {
1180
- allSlides.eq(_.options.slidesToShow).addClass('slick-center');
1181
- }
1225
+ };
1182
1226
 
1183
- _.$slides.eq(index).addClass('slick-center');
1184
1227
 
1185
- } else {
1228
+ Slick.prototype.setSlideClasses = function(index) {
1186
1229
 
1187
- if (index > 0 && index < (_.slideCount - _.options.slidesToShow)) {
1188
- _.$slides.slice(index, index + _.options.slidesToShow).addClass('slick-active');
1189
- } else if ( allSlides.length <= _.options.slidesToShow ) {
1190
- allSlides.addClass('slick-active');
1191
- } else {
1192
- indexOffset = _.options.infinite === true ? _.options.slidesToShow + index : index;
1193
- allSlides.slice(indexOffset, indexOffset + _.options.slidesToShow).addClass('slick-active');
1194
- }
1230
+ var _ = this,
1231
+ centerOffset, allSlides, indexOffset, remainder;
1195
1232
 
1196
- }
1233
+ _.$slider.find('.slick-slide').removeClass('slick-active').removeClass('slick-center');
1234
+ allSlides = _.$slider.find('.slick-slide');
1197
1235
 
1198
- if (_.options.lazyLoad === 'ondemand') {
1199
- _.lazyLoad();
1200
- }
1236
+ if (_.options.centerMode === true) {
1201
1237
 
1202
- };
1238
+ centerOffset = Math.floor(_.options.slidesToShow / 2);
1203
1239
 
1204
- Slick.prototype.setupInfinite = function() {
1240
+ if(_.options.infinite === true) {
1205
1241
 
1206
- var _ = this,
1207
- i, slideIndex, infiniteCount;
1242
+ if (index >= centerOffset && index <= (_.slideCount - 1) - centerOffset) {
1243
+ _.$slides.slice(index - centerOffset, index + centerOffset + 1).addClass('slick-active');
1244
+ } else {
1245
+ indexOffset = _.options.slidesToShow + index;
1246
+ allSlides.slice(indexOffset - centerOffset + 1, indexOffset + centerOffset + 2).addClass('slick-active');
1247
+ }
1208
1248
 
1209
- if (_.options.fade === true || _.options.vertical === true) {
1210
- _.options.centerMode = false;
1249
+ if (index === 0) {
1250
+ allSlides.eq(allSlides.length - 1 - _.options.slidesToShow).addClass('slick-center');
1251
+ } else if (index === _.slideCount - 1) {
1252
+ allSlides.eq(_.options.slidesToShow).addClass('slick-center');
1211
1253
  }
1212
1254
 
1213
- if (_.options.infinite === true && _.options.fade === false) {
1214
-
1215
- slideIndex = null;
1216
-
1217
- if (_.slideCount > _.options.slidesToShow) {
1218
-
1219
- if (_.options.centerMode === true) {
1220
- infiniteCount = _.options.slidesToShow + 1;
1221
- } else {
1222
- infiniteCount = _.options.slidesToShow;
1223
- }
1224
-
1225
- for (i = _.slideCount; i > (_.slideCount -
1226
- infiniteCount); i -= 1) {
1227
- slideIndex = i - 1;
1228
- $(_.$slides[slideIndex]).clone().attr('id', '').prependTo(
1229
- _.$slideTrack).addClass('slick-cloned');
1230
- }
1231
- for (i = 0; i < infiniteCount; i += 1) {
1232
- slideIndex = i;
1233
- $(_.$slides[slideIndex]).clone().attr('id', '').appendTo(
1234
- _.$slideTrack).addClass('slick-cloned');
1235
- }
1236
- _.$slideTrack.find('.slick-cloned').find('[id]').each(function() {
1237
- $(this).attr('id', '');
1238
- });
1255
+ }
1239
1256
 
1240
- }
1257
+ _.$slides.eq(index).addClass('slick-center');
1258
+
1259
+ } else {
1241
1260
 
1261
+ if (index >= 0 && index <= (_.slideCount - _.options.slidesToShow)) {
1262
+ _.$slides.slice(index, index + _.options.slidesToShow).addClass('slick-active');
1263
+ } else if ( allSlides.length <= _.options.slidesToShow ) {
1264
+ allSlides.addClass('slick-active');
1265
+ } else {
1266
+ remainder = _.slideCount%_.options.slidesToShow;
1267
+ indexOffset = _.options.infinite === true ? _.options.slidesToShow + index : index;
1268
+ if(_.options.slidesToShow == _.options.slidesToScroll && (_.slideCount - index) < _.options.slidesToShow) {
1269
+ allSlides.slice(indexOffset-(_.options.slidesToShow-remainder), indexOffset + remainder).addClass('slick-active');
1270
+ } else {
1271
+ allSlides.slice(indexOffset, indexOffset + _.options.slidesToShow).addClass('slick-active');
1242
1272
  }
1273
+ }
1243
1274
 
1244
- };
1275
+ }
1245
1276
 
1246
- Slick.prototype.slideHandler = function(index) {
1277
+ if (_.options.lazyLoad === 'ondemand') {
1278
+ _.lazyLoad();
1279
+ }
1247
1280
 
1248
- var targetSlide, animSlide, slideLeft, unevenOffset, targetLeft = null,
1249
- _ = this;
1281
+ };
1250
1282
 
1251
- if (_.animating === true) {
1252
- return false;
1253
- }
1283
+ Slick.prototype.setupInfinite = function() {
1254
1284
 
1255
- targetSlide = index;
1256
- targetLeft = _.getLeft(targetSlide);
1257
- slideLeft = _.getLeft(_.currentSlide);
1285
+ var _ = this,
1286
+ i, slideIndex, infiniteCount;
1258
1287
 
1259
- unevenOffset = _.slideCount % _.options.slidesToScroll !== 0 ? _.options.slidesToScroll : 0;
1288
+ if (_.options.fade === true || _.options.vertical === true) {
1289
+ _.options.centerMode = false;
1290
+ }
1260
1291
 
1261
- _.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;
1292
+ if (_.options.infinite === true && _.options.fade === false) {
1262
1293
 
1263
- if (_.options.infinite === false && (index < 0 || index > (_.slideCount - _.options.slidesToShow + unevenOffset))) {
1264
- if(_.options.fade === false) {
1265
- targetSlide = _.currentSlide;
1266
- _.animateSlide(slideLeft, function() {
1267
- _.postSlide(targetSlide);
1268
- });
1269
- }
1270
- return false;
1271
- }
1294
+ slideIndex = null;
1272
1295
 
1273
- if (_.options.autoplay === true) {
1274
- clearInterval(_.autoPlayTimer);
1275
- }
1296
+ if (_.slideCount > _.options.slidesToShow) {
1276
1297
 
1277
- if (targetSlide < 0) {
1278
- if (_.slideCount % _.options.slidesToScroll !== 0) {
1279
- animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll);
1280
- } else {
1281
- animSlide = _.slideCount - _.options.slidesToScroll;
1282
- }
1283
- } else if (targetSlide > (_.slideCount - 1)) {
1284
- animSlide = 0;
1298
+ if (_.options.centerMode === true) {
1299
+ infiniteCount = _.options.slidesToShow + 1;
1285
1300
  } else {
1286
- animSlide = targetSlide;
1301
+ infiniteCount = _.options.slidesToShow;
1287
1302
  }
1288
1303
 
1289
- _.animating = true;
1290
-
1291
- if (_.options.onBeforeChange !== null && index !== _.currentSlide) {
1292
- _.options.onBeforeChange.call(this, _, _.currentSlide, animSlide);
1304
+ for (i = _.slideCount; i > (_.slideCount -
1305
+ infiniteCount); i -= 1) {
1306
+ slideIndex = i - 1;
1307
+ $(_.$slides[slideIndex]).clone(true).attr('id', '').prependTo(
1308
+ _.$slideTrack).addClass('slick-cloned');
1309
+ }
1310
+ for (i = 0; i < infiniteCount; i += 1) {
1311
+ slideIndex = i;
1312
+ $(_.$slides[slideIndex]).clone(true).attr('id', '').appendTo(
1313
+ _.$slideTrack).addClass('slick-cloned');
1293
1314
  }
1315
+ _.$slideTrack.find('.slick-cloned').find('[id]').each(function() {
1316
+ $(this).attr('id', '');
1317
+ });
1294
1318
 
1295
- _.currentSlide = animSlide;
1319
+ }
1296
1320
 
1297
- _.setSlideClasses(_.currentSlide);
1321
+ }
1298
1322
 
1299
- _.updateDots();
1300
- _.updateArrows();
1323
+ };
1301
1324
 
1302
- if (_.options.fade === true) {
1303
- _.fadeSlide(animSlide, function() {
1304
- _.postSlide(animSlide);
1305
- });
1306
- return false;
1307
- }
1325
+ Slick.prototype.selectHandler = function(event) {
1326
+
1327
+ var _ = this;
1328
+ var asNavFor = _.options.asNavFor != null ? $(_.options.asNavFor).getSlick() : null;
1329
+ var index = parseInt($(event.target).parent().attr("index"));
1330
+ if(!index) index = 0;
1331
+
1332
+ if(_.slideCount <= _.options.slidesToShow){
1333
+ return;
1334
+ }
1335
+ _.slideHandler(index);
1336
+
1337
+ if(asNavFor != null){
1338
+ if(asNavFor.slideCount <= asNavFor.options.slidesToShow){
1339
+ return;
1340
+ }
1341
+ asNavFor.slideHandler(index);
1342
+ }
1343
+ };
1344
+
1345
+ Slick.prototype.slideHandler = function(index) {
1346
+
1347
+ var targetSlide, animSlide, slideLeft, unevenOffset, targetLeft = null,
1348
+ _ = this;
1349
+
1350
+ if (_.animating === true) {
1351
+ return false;
1352
+ }
1353
+
1354
+ targetSlide = index;
1355
+ targetLeft = _.getLeft(targetSlide);
1356
+ slideLeft = _.getLeft(_.currentSlide);
1357
+
1358
+ unevenOffset = _.slideCount % _.options.slidesToScroll !== 0 ? _.options.slidesToScroll : 0;
1359
+
1360
+ _.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;
1308
1361
 
1309
- _.animateSlide(targetLeft, function() {
1310
- _.postSlide(animSlide);
1362
+ if (_.options.infinite === false && _.options.centerMode === false && (index < 0 || index > (_.slideCount - _.options.slidesToShow + unevenOffset))) {
1363
+ if(_.options.fade === false) {
1364
+ targetSlide = _.currentSlide;
1365
+ _.animateSlide(slideLeft, function() {
1366
+ _.postSlide(targetSlide);
1311
1367
  });
1368
+ }
1369
+ return false;
1370
+ } else if (_.options.infinite === false && _.options.centerMode === true && (index < 0 || index > (_.slideCount - _.options.slidesToScroll))) {
1371
+ if(_.options.fade === false) {
1372
+ targetSlide = _.currentSlide;
1373
+ _.animateSlide(slideLeft, function() {
1374
+ _.postSlide(targetSlide);
1375
+ });
1376
+ }
1377
+ return false;
1378
+ }
1312
1379
 
1313
- };
1380
+ if (_.options.autoplay === true) {
1381
+ clearInterval(_.autoPlayTimer);
1382
+ }
1314
1383
 
1315
- Slick.prototype.startLoad = function() {
1384
+ if (targetSlide < 0) {
1385
+ if (_.slideCount % _.options.slidesToScroll !== 0) {
1386
+ animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll);
1387
+ } else {
1388
+ animSlide = _.slideCount - _.options.slidesToScroll;
1389
+ }
1390
+ } else if (targetSlide > (_.slideCount - 1)) {
1391
+ animSlide = 0;
1392
+ } else {
1393
+ animSlide = targetSlide;
1394
+ }
1316
1395
 
1317
- var _ = this;
1396
+ _.animating = true;
1318
1397
 
1319
- if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1398
+ if (_.options.onBeforeChange !== null && index !== _.currentSlide) {
1399
+ _.options.onBeforeChange.call(this, _, _.currentSlide, animSlide);
1400
+ }
1320
1401
 
1321
- _.$prevArrow.hide();
1322
- _.$nextArrow.hide();
1402
+ _.currentSlide = animSlide;
1323
1403
 
1324
- }
1404
+ _.setSlideClasses(_.currentSlide);
1325
1405
 
1326
- if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1406
+ _.updateDots();
1407
+ _.updateArrows();
1327
1408
 
1328
- _.$dots.hide();
1409
+ if (_.options.fade === true) {
1410
+ _.fadeSlide(animSlide, function() {
1411
+ _.postSlide(animSlide);
1412
+ });
1413
+ return false;
1414
+ }
1329
1415
 
1330
- }
1416
+ _.animateSlide(targetLeft, function() {
1417
+ _.postSlide(animSlide);
1418
+ });
1331
1419
 
1332
- _.$slider.addClass('slick-loading');
1420
+ };
1333
1421
 
1334
- };
1422
+ Slick.prototype.startLoad = function() {
1335
1423
 
1336
- Slick.prototype.swipeDirection = function() {
1424
+ var _ = this;
1337
1425
 
1338
- var xDist, yDist, r, swipeAngle, _ = this;
1426
+ if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {
1339
1427
 
1340
- xDist = _.touchObject.startX - _.touchObject.curX;
1341
- yDist = _.touchObject.startY - _.touchObject.curY;
1342
- r = Math.atan2(yDist, xDist);
1428
+ _.$prevArrow.hide();
1429
+ _.$nextArrow.hide();
1343
1430
 
1344
- swipeAngle = Math.round(r * 180 / Math.PI);
1345
- if (swipeAngle < 0) {
1346
- swipeAngle = 360 - Math.abs(swipeAngle);
1347
- }
1431
+ }
1348
1432
 
1349
- if ((swipeAngle <= 45) && (swipeAngle >= 0)) {
1350
- return 'left';
1351
- }
1352
- if ((swipeAngle <= 360) && (swipeAngle >= 315)) {
1353
- return 'left';
1354
- }
1355
- if ((swipeAngle >= 135) && (swipeAngle <= 225)) {
1356
- return 'right';
1357
- }
1433
+ if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {
1358
1434
 
1359
- return 'vertical';
1435
+ _.$dots.hide();
1360
1436
 
1361
- };
1437
+ }
1362
1438
 
1363
- Slick.prototype.swipeEnd = function(event) {
1439
+ _.$slider.addClass('slick-loading');
1364
1440
 
1365
- var _ = this;
1441
+ };
1366
1442
 
1367
- _.$list.removeClass('dragging');
1443
+ Slick.prototype.swipeDirection = function() {
1368
1444
 
1369
- if (_.touchObject.curX === undefined) {
1370
- return false;
1371
- }
1445
+ var xDist, yDist, r, swipeAngle, _ = this;
1372
1446
 
1373
- if (_.touchObject.swipeLength >= _.touchObject.minSwipe) {
1374
- $(event.target).on('click.slick', function(event) {
1375
- event.stopImmediatePropagation();
1376
- event.stopPropagation();
1377
- event.preventDefault();
1378
- $(event.target).off('click.slick');
1379
- });
1380
-
1381
- switch (_.swipeDirection()) {
1382
- case 'left':
1383
- _.slideHandler(_.currentSlide + _.options.slidesToScroll);
1384
- _.touchObject = {};
1385
- break;
1386
-
1387
- case 'right':
1388
- _.slideHandler(_.currentSlide - _.options.slidesToScroll);
1389
- _.touchObject = {};
1390
- break;
1391
- }
1392
- } else {
1393
- if(_.touchObject.startX !== _.touchObject.curX) {
1394
- _.slideHandler(_.currentSlide);
1395
- _.touchObject = {};
1396
- }
1397
- }
1447
+ xDist = _.touchObject.startX - _.touchObject.curX;
1448
+ yDist = _.touchObject.startY - _.touchObject.curY;
1449
+ r = Math.atan2(yDist, xDist);
1398
1450
 
1399
- };
1451
+ swipeAngle = Math.round(r * 180 / Math.PI);
1452
+ if (swipeAngle < 0) {
1453
+ swipeAngle = 360 - Math.abs(swipeAngle);
1454
+ }
1400
1455
 
1401
- Slick.prototype.swipeHandler = function(event) {
1456
+ if ((swipeAngle <= 45) && (swipeAngle >= 0)) {
1457
+ return 'left';
1458
+ }
1459
+ if ((swipeAngle <= 360) && (swipeAngle >= 315)) {
1460
+ return 'left';
1461
+ }
1462
+ if ((swipeAngle >= 135) && (swipeAngle <= 225)) {
1463
+ return 'right';
1464
+ }
1402
1465
 
1403
- var _ = this;
1466
+ return 'vertical';
1404
1467
 
1405
- if ((_.options.swipe === false) || ('ontouchend' in document && _.options.swipe === false)) {
1406
- return undefined;
1407
- } else if ((_.options.draggable === false) || (_.options.draggable === false && !event.originalEvent.touches)) {
1408
- return undefined;
1409
- }
1468
+ };
1410
1469
 
1411
- _.touchObject.fingerCount = event.originalEvent && event.originalEvent.touches !== undefined ?
1412
- event.originalEvent.touches.length : 1;
1470
+ Slick.prototype.swipeEnd = function(event) {
1413
1471
 
1414
- _.touchObject.minSwipe = _.listWidth / _.options
1415
- .touchThreshold;
1472
+ var _ = this;
1473
+ var asNavFor = _.options.asNavFor != null ? $(_.options.asNavFor).getSlick() : null;
1416
1474
 
1417
- switch (event.data.action) {
1475
+ _.dragging = false;
1418
1476
 
1419
- case 'start':
1420
- _.swipeStart(event);
1421
- break;
1477
+ if (_.touchObject.curX === undefined) {
1478
+ return false;
1479
+ }
1422
1480
 
1423
- case 'move':
1424
- _.swipeMove(event);
1425
- break;
1481
+ if (_.touchObject.swipeLength >= _.touchObject.minSwipe) {
1482
+ $(event.target).on('click.slick', function(event) {
1483
+ event.stopImmediatePropagation();
1484
+ event.stopPropagation();
1485
+ event.preventDefault();
1486
+ $(event.target).off('click.slick');
1487
+ });
1488
+
1489
+ switch (_.swipeDirection()) {
1490
+ case 'left':
1491
+ _.slideHandler(_.currentSlide + _.options.slidesToScroll);
1492
+ if(asNavFor != null) asNavFor.slideHandler(asNavFor.currentSlide + asNavFor.options.slidesToScroll);
1493
+ _.touchObject = {};
1494
+ break;
1495
+
1496
+ case 'right':
1497
+ _.slideHandler(_.currentSlide - _.options.slidesToScroll);
1498
+ if(asNavFor != null) asNavFor.slideHandler(asNavFor.currentSlide - asNavFor.options.slidesToScroll);
1499
+ _.touchObject = {};
1500
+ break;
1501
+ }
1502
+ } else {
1503
+ if(_.touchObject.startX !== _.touchObject.curX) {
1504
+ _.slideHandler(_.currentSlide);
1505
+ if(asNavFor != null) asNavFor.slideHandler(asNavFor.currentSlide);
1506
+ _.touchObject = {};
1507
+ }
1508
+ }
1426
1509
 
1427
- case 'end':
1428
- _.swipeEnd(event);
1429
- break;
1510
+ };
1430
1511
 
1431
- }
1512
+ Slick.prototype.swipeHandler = function(event) {
1432
1513
 
1433
- };
1514
+ var _ = this;
1434
1515
 
1435
- Slick.prototype.swipeMove = function(event) {
1516
+ if ((_.options.swipe === false) || ('ontouchend' in document && _.options.swipe === false)) {
1517
+ return;
1518
+ } else if ((_.options.draggable === false) || (_.options.draggable === false && !event.originalEvent.touches)) {
1519
+ return;
1520
+ }
1436
1521
 
1437
- var _ = this,
1438
- curLeft, swipeDirection, positionOffset, touches;
1522
+ _.touchObject.fingerCount = event.originalEvent && event.originalEvent.touches !== undefined ?
1523
+ event.originalEvent.touches.length : 1;
1439
1524
 
1440
- touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;
1525
+ _.touchObject.minSwipe = _.listWidth / _.options
1526
+ .touchThreshold;
1441
1527
 
1442
- curLeft = _.getLeft(_.currentSlide);
1528
+ switch (event.data.action) {
1443
1529
 
1444
- if (!_.$list.hasClass('dragging') || touches && touches.length !== 1) {
1445
- return false;
1446
- }
1530
+ case 'start':
1531
+ _.swipeStart(event);
1532
+ break;
1447
1533
 
1448
- _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;
1449
- _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;
1534
+ case 'move':
1535
+ _.swipeMove(event);
1536
+ break;
1450
1537
 
1451
- _.touchObject.swipeLength = Math.round(Math.sqrt(
1452
- Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));
1538
+ case 'end':
1539
+ _.swipeEnd(event);
1540
+ break;
1453
1541
 
1454
- swipeDirection = _.swipeDirection();
1542
+ }
1455
1543
 
1456
- if (swipeDirection === 'vertical') {
1457
- return;
1458
- }
1544
+ };
1459
1545
 
1460
- if (event.originalEvent !== undefined && _.touchObject.swipeLength > 4) {
1461
- event.preventDefault();
1462
- }
1546
+ Slick.prototype.swipeMove = function(event) {
1463
1547
 
1464
- positionOffset = _.touchObject.curX > _.touchObject.startX ? 1 : -1;
1548
+ var _ = this,
1549
+ curLeft, swipeDirection, positionOffset, touches;
1465
1550
 
1466
- if (_.options.vertical === false) {
1467
- _.swipeLeft = curLeft + _.touchObject.swipeLength * positionOffset;
1468
- } else {
1469
- _.swipeLeft = curLeft + (_.touchObject
1470
- .swipeLength * (_.$list.height() / _.listWidth)) * positionOffset;
1471
- }
1551
+ touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;
1472
1552
 
1473
- if (_.options.fade === true || _.options.touchMove === false) {
1474
- return false;
1475
- }
1553
+ curLeft = _.getLeft(_.currentSlide);
1476
1554
 
1477
- if (_.animating === true) {
1478
- _.swipeLeft = null;
1479
- return false;
1480
- }
1555
+ if (!_.dragging || touches && touches.length !== 1) {
1556
+ return false;
1557
+ }
1481
1558
 
1482
- _.setCSS(_.swipeLeft);
1559
+ _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;
1560
+ _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;
1483
1561
 
1484
- };
1562
+ _.touchObject.swipeLength = Math.round(Math.sqrt(
1563
+ Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));
1485
1564
 
1486
- Slick.prototype.swipeStart = function(event) {
1565
+ swipeDirection = _.swipeDirection();
1487
1566
 
1488
- var _ = this,
1489
- touches;
1567
+ if (swipeDirection === 'vertical') {
1568
+ return;
1569
+ }
1490
1570
 
1491
- if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {
1492
- _.touchObject = {};
1493
- return false;
1494
- }
1571
+ if (event.originalEvent !== undefined && _.touchObject.swipeLength > 4) {
1572
+ event.preventDefault();
1573
+ }
1495
1574
 
1496
- if (event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {
1497
- touches = event.originalEvent.touches[0];
1498
- }
1575
+ positionOffset = _.touchObject.curX > _.touchObject.startX ? 1 : -1;
1499
1576
 
1500
- _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;
1501
- _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;
1577
+ if (_.options.vertical === false) {
1578
+ _.swipeLeft = curLeft + _.touchObject.swipeLength * positionOffset;
1579
+ } else {
1580
+ _.swipeLeft = curLeft + (_.touchObject
1581
+ .swipeLength * (_.$list.height() / _.listWidth)) * positionOffset;
1582
+ }
1502
1583
 
1503
- _.$list.addClass('dragging');
1584
+ if (_.options.fade === true || _.options.touchMove === false) {
1585
+ return false;
1586
+ }
1504
1587
 
1505
- };
1588
+ if (_.animating === true) {
1589
+ _.swipeLeft = null;
1590
+ return false;
1591
+ }
1506
1592
 
1507
- Slick.prototype.unfilterSlides = function() {
1593
+ _.setCSS(_.swipeLeft);
1508
1594
 
1509
- var _ = this;
1595
+ };
1510
1596
 
1511
- if (_.$slidesCache !== null) {
1597
+ Slick.prototype.swipeStart = function(event) {
1512
1598
 
1513
- _.unload();
1599
+ var _ = this,
1600
+ touches;
1514
1601
 
1515
- _.$slideTrack.children(this.options.slide).remove();
1602
+ if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {
1603
+ _.touchObject = {};
1604
+ return false;
1605
+ }
1516
1606
 
1517
- _.$slidesCache.appendTo(_.$slideTrack);
1607
+ if (event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {
1608
+ touches = event.originalEvent.touches[0];
1609
+ }
1518
1610
 
1519
- _.reinit();
1611
+ _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;
1612
+ _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;
1520
1613
 
1521
- }
1614
+ _.dragging = true;
1522
1615
 
1523
- };
1616
+ };
1524
1617
 
1525
- Slick.prototype.unload = function() {
1618
+ Slick.prototype.unfilterSlides = function() {
1526
1619
 
1527
- var _ = this;
1620
+ var _ = this;
1528
1621
 
1529
- $('.slick-cloned', _.$slider).remove();
1530
- if (_.$dots) {
1531
- _.$dots.remove();
1532
- }
1533
- if (_.$prevArrow) {
1534
- _.$prevArrow.remove();
1535
- _.$nextArrow.remove();
1536
- }
1537
- _.$slides.removeClass(
1538
- 'slick-slide slick-active slick-visible').removeAttr('style');
1622
+ if (_.$slidesCache !== null) {
1539
1623
 
1540
- };
1624
+ _.unload();
1541
1625
 
1542
- Slick.prototype.updateArrows = function() {
1626
+ _.$slideTrack.children(this.options.slide).detach();
1543
1627
 
1544
- var _ = this;
1628
+ _.$slidesCache.appendTo(_.$slideTrack);
1545
1629
 
1546
- if (_.options.arrows === true && _.options.infinite !==
1547
- true && _.slideCount > _.options.slidesToShow) {
1548
- _.$prevArrow.removeClass('slick-disabled');
1549
- _.$nextArrow.removeClass('slick-disabled');
1550
- if (_.currentSlide === 0) {
1551
- _.$prevArrow.addClass('slick-disabled');
1552
- _.$nextArrow.removeClass('slick-disabled');
1553
- } else if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
1554
- _.$nextArrow.addClass('slick-disabled');
1555
- _.$prevArrow.removeClass('slick-disabled');
1556
- }
1557
- }
1630
+ _.reinit();
1558
1631
 
1559
- };
1632
+ }
1560
1633
 
1561
- Slick.prototype.updateDots = function() {
1634
+ };
1562
1635
 
1563
- var _ = this;
1636
+ Slick.prototype.unload = function() {
1564
1637
 
1565
- if (_.$dots !== null) {
1638
+ var _ = this;
1566
1639
 
1567
- _.$dots.find('li').removeClass('slick-active');
1568
- _.$dots.find('li').eq(_.currentSlide / _.options.slidesToScroll).addClass(
1569
- 'slick-active');
1640
+ $('.slick-cloned', _.$slider).remove();
1641
+ if (_.$dots) {
1642
+ _.$dots.remove();
1643
+ }
1644
+ if (_.$prevArrow) {
1645
+ _.$prevArrow.remove();
1646
+ _.$nextArrow.remove();
1647
+ }
1648
+ _.$slides.removeClass(
1649
+ 'slick-slide slick-active slick-visible').removeAttr('style');
1650
+
1651
+ };
1652
+
1653
+ Slick.prototype.updateArrows = function() {
1654
+
1655
+ var _ = this;
1656
+
1657
+ if (_.options.arrows === true && _.options.infinite !==
1658
+ true && _.slideCount > _.options.slidesToShow) {
1659
+ _.$prevArrow.removeClass('slick-disabled');
1660
+ _.$nextArrow.removeClass('slick-disabled');
1661
+ if (_.currentSlide === 0) {
1662
+ _.$prevArrow.addClass('slick-disabled');
1663
+ _.$nextArrow.removeClass('slick-disabled');
1664
+ } else if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {
1665
+ _.$nextArrow.addClass('slick-disabled');
1666
+ _.$prevArrow.removeClass('slick-disabled');
1667
+ }
1668
+ }
1570
1669
 
1571
- }
1670
+ };
1572
1671
 
1573
- };
1672
+ Slick.prototype.updateDots = function() {
1574
1673
 
1575
- $.fn.slick = function(options) {
1576
- var _ = this;
1577
- return _.each(function(index, element) {
1674
+ var _ = this;
1578
1675
 
1579
- element.slick = new Slick(element, options);
1676
+ if (_.$dots !== null) {
1580
1677
 
1581
- });
1582
- };
1678
+ _.$dots.find('li').removeClass('slick-active');
1679
+ _.$dots.find('li').eq(Math.floor(_.currentSlide / _.options.slidesToScroll)).addClass('slick-active');
1583
1680
 
1584
- $.fn.slickAdd = function(slide, slideIndex, addBefore) {
1585
- var _ = this;
1586
- return _.each(function(index, element) {
1681
+ }
1587
1682
 
1588
- element.slick.addSlide(slide, slideIndex, addBefore);
1683
+ };
1589
1684
 
1590
- });
1591
- };
1685
+ $.fn.slick = function(options) {
1686
+ var _ = this;
1687
+ return _.each(function(index, element) {
1592
1688
 
1593
- $.fn.slickCurrentSlide = function() {
1594
- var _ = this;
1595
- return _.get(0).slick.getCurrent();
1596
- };
1689
+ element.slick = new Slick(element, options);
1597
1690
 
1598
- $.fn.slickFilter = function(filter) {
1599
- var _ = this;
1600
- return _.each(function(index, element) {
1691
+ });
1692
+ };
1601
1693
 
1602
- element.slick.filterSlides(filter);
1694
+ $.fn.slickAdd = function(slide, slideIndex, addBefore) {
1695
+ var _ = this;
1696
+ return _.each(function(index, element) {
1603
1697
 
1604
- });
1605
- };
1698
+ element.slick.addSlide(slide, slideIndex, addBefore);
1606
1699
 
1607
- $.fn.slickGoTo = function(slide) {
1608
- var _ = this;
1609
- return _.each(function(index, element) {
1700
+ });
1701
+ };
1610
1702
 
1611
- element.slick.slideHandler(slide);
1703
+ $.fn.slickCurrentSlide = function() {
1704
+ var _ = this;
1705
+ return _.get(0).slick.getCurrent();
1706
+ };
1612
1707
 
1613
- });
1614
- };
1708
+ $.fn.slickFilter = function(filter) {
1709
+ var _ = this;
1710
+ return _.each(function(index, element) {
1615
1711
 
1616
- $.fn.slickNext = function() {
1617
- var _ = this;
1618
- return _.each(function(index, element) {
1712
+ element.slick.filterSlides(filter);
1619
1713
 
1620
- element.slick.changeSlide({
1621
- data: {
1622
- message: 'next'
1623
- }
1624
- });
1714
+ });
1715
+ };
1625
1716
 
1626
- });
1627
- };
1717
+ $.fn.slickGoTo = function(slide) {
1718
+ var _ = this;
1719
+ return _.each(function(index, element) {
1628
1720
 
1629
- $.fn.slickPause = function() {
1630
- var _ = this;
1631
- return _.each(function(index, element) {
1721
+ var asNavFor = element.slick.options.asNavFor != null ? $(element.slick.options.asNavFor) : null;
1722
+ if(asNavFor != null) asNavFor.slickGoTo(slide);
1723
+ element.slick.slideHandler(slide);
1632
1724
 
1633
- element.slick.autoPlayClear();
1634
- element.slick.paused = true;
1725
+ });
1726
+ };
1635
1727
 
1636
- });
1637
- };
1728
+ $.fn.slickNext = function() {
1729
+ var _ = this;
1730
+ return _.each(function(index, element) {
1638
1731
 
1639
- $.fn.slickPlay = function() {
1640
- var _ = this;
1641
- return _.each(function(index, element) {
1732
+ element.slick.changeSlide({
1733
+ data: {
1734
+ message: 'next'
1735
+ }
1736
+ });
1642
1737
 
1643
- element.slick.paused = false;
1644
- element.slick.autoPlay();
1738
+ });
1739
+ };
1645
1740
 
1646
- });
1647
- };
1741
+ $.fn.slickPause = function() {
1742
+ var _ = this;
1743
+ return _.each(function(index, element) {
1648
1744
 
1649
- $.fn.slickPrev = function() {
1650
- var _ = this;
1651
- return _.each(function(index, element) {
1745
+ element.slick.autoPlayClear();
1746
+ element.slick.paused = true;
1652
1747
 
1653
- element.slick.changeSlide({
1654
- data: {
1655
- message: 'previous'
1656
- }
1657
- });
1748
+ });
1749
+ };
1658
1750
 
1659
- });
1660
- };
1751
+ $.fn.slickPlay = function() {
1752
+ var _ = this;
1753
+ return _.each(function(index, element) {
1661
1754
 
1662
- $.fn.slickRemove = function(slideIndex, removeBefore) {
1663
- var _ = this;
1664
- return _.each(function(index, element) {
1755
+ element.slick.paused = false;
1756
+ element.slick.autoPlay();
1665
1757
 
1666
- element.slick.removeSlide(slideIndex, removeBefore);
1758
+ });
1759
+ };
1667
1760
 
1668
- });
1669
- };
1761
+ $.fn.slickPrev = function() {
1762
+ var _ = this;
1763
+ return _.each(function(index, element) {
1670
1764
 
1671
- $.fn.slickSetOption = function(option, value, refresh) {
1672
- var _ = this;
1673
- return _.each(function(index, element) {
1765
+ element.slick.changeSlide({
1766
+ data: {
1767
+ message: 'previous'
1768
+ }
1769
+ });
1674
1770
 
1675
- element.slick.options[option] = value;
1771
+ });
1772
+ };
1676
1773
 
1677
- if (refresh === true) {
1678
- element.slick.unload();
1679
- element.slick.reinit();
1680
- }
1774
+ $.fn.slickRemove = function(slideIndex, removeBefore) {
1775
+ var _ = this;
1776
+ return _.each(function(index, element) {
1681
1777
 
1682
- });
1683
- };
1778
+ element.slick.removeSlide(slideIndex, removeBefore);
1684
1779
 
1685
- $.fn.slickUnfilter = function() {
1686
- var _ = this;
1687
- return _.each(function(index, element) {
1780
+ });
1781
+ };
1688
1782
 
1689
- element.slick.unfilterSlides();
1783
+ $.fn.slickGetOption = function(option) {
1784
+ var _ = this;
1785
+ return _.get(0).slick.options[option];
1786
+ };
1690
1787
 
1691
- });
1692
- };
1788
+ $.fn.slickSetOption = function(option, value, refresh) {
1789
+ var _ = this;
1790
+ return _.each(function(index, element) {
1693
1791
 
1694
- $.fn.unslick = function() {
1695
- var _ = this;
1696
- return _.each(function(index, element) {
1792
+ element.slick.options[option] = value;
1697
1793
 
1698
- element.slick.destroy();
1794
+ if (refresh === true) {
1795
+ element.slick.unload();
1796
+ element.slick.reinit();
1797
+ }
1699
1798
 
1700
- });
1701
- };
1799
+ });
1800
+ };
1801
+
1802
+ $.fn.slickUnfilter = function() {
1803
+ var _ = this;
1804
+ return _.each(function(index, element) {
1805
+
1806
+ element.slick.unfilterSlides();
1807
+
1808
+ });
1809
+ };
1810
+
1811
+ $.fn.unslick = function() {
1812
+ var _ = this;
1813
+ return _.each(function(index, element) {
1814
+
1815
+ if (element.slick) {
1816
+ element.slick.destroy();
1817
+ }
1818
+
1819
+ });
1820
+ };
1821
+
1822
+ $.fn.getSlick = function() {
1823
+ var s = null;
1824
+ var _ = this;
1825
+ _.each(function(index, element) {
1826
+ s = element.slick;
1827
+ });
1828
+
1829
+ return s;
1830
+ };
1702
1831
 
1703
1832
  }));