slick_rails 1.2.5.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4f2f4d5f8fe5ad7255a946c3cc36d6ff9027bd0f
+  data.tar.gz: 064cc666b9349f3fec6b0b92e85061d9b3a16fbc
+SHA512:
+  metadata.gz: 55de4756b117d8308bdafa1731374b4893260968932c8a7b566fb8dcbac38c068798d167c44c3fd05e8b8418acbf0e410684b3c5e5d6dbb655d34d285fb4dcf2
+  data.tar.gz: b8f7d44838d166cbc6f777c0e71f74d88d5a158cdd22a058a7394ee41dec0e26dd9c5e955853cbfcb87644d5039ee8f579d587cde808fb9d13e61e82f0501e26

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in slick_rails.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Guy Israeli
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,49 @@
+# SlickRails
+
+Slick Carousel for Rails 3.1+ asset pipeline
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'slick_rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install slick_rails
+
+## Usage
+
+add to js manifests
+    
+    //= require slick
+    
+and to css manifest
+    
+    *= require slick
+    
+Note: This plugin has custom fonts for dots and arrows and such. These are provided in /fonts (from the original     repo) and are referred in the css.
+    
+If you want them make sure the asset pipeline will handle them with something like
+    
+    config.assets.precompile += %w( .js .css *.css.scss .svg .eot .woff .ttf)
+    
+if you don't want them - ignore what I just wrote, and overwrite
+    .slick-prev:before
+    .slick-next:before
+    .slick-dots li a:before 
+
+
+
+see instruction and full info in https://github.com/kenwheeler/slick
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/slick_rails/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/app/assets/fonts/slick.svg

@@ -0,0 +1,13 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg">
+<metadata>Generated by Fontastic.me</metadata>
+<defs>
+<font id="slick" horiz-adv-x="512">
+<font-face font-family="slick" units-per-em="512" ascent="480" descent="-32"/>
+<missing-glyph horiz-adv-x="512" />
+
+<glyph unicode="&#34196;" d="M241 113l130 130c4 4 6 8 6 13 0 5-2 9-6 13l-130 130c-3 3-7 5-12 5-5 0-10-2-13-5l-29-30c-4-3-6-7-6-12 0-5 2-10 6-13l87-88-87-88c-4-3-6-8-6-13 0-5 2-9 6-12l29-30c3-3 8-5 13-5 5 0 9 2 12 5z m234 143c0-40-9-77-29-110-20-34-46-60-80-80-33-20-70-29-110-29-40 0-77 9-110 29-34 20-60 46-80 80-20 33-29 70-29 110 0 40 9 77 29 110 20 34 46 60 80 80 33 20 70 29 110 29 40 0 77-9 110-29 34-20 60-46 80-80 20-33 29-70 29-110z"/>
+<glyph unicode="&#34194;" d="M296 113l29 30c4 3 6 7 6 12 0 5-2 10-6 13l-87 88 87 88c4 3 6 8 6 13 0 5-2 9-6 12l-29 30c-3 3-8 5-13 5-5 0-9-2-12-5l-130-130c-4-4-6-8-6-13 0-5 2-9 6-13l130-130c3-3 7-5 12-5 5 0 10 2 13 5z m179 143c0-40-9-77-29-110-20-34-46-60-80-80-33-20-70-29-110-29-40 0-77 9-110 29-34 20-60 46-80 80-20 33-29 70-29 110 0 40 9 77 29 110 20 34 46 60 80 80 33 20 70 29 110 29 40 0 77-9 110-29 34-20 60-46 80-80 20-33 29-70 29-110z"/>
+<glyph unicode="&#33318;" d="M475 256c0-40-9-77-29-110-20-34-46-60-80-80-33-20-70-29-110-29-40 0-77 9-110 29-34 20-60 46-80 80-20 33-29 70-29 110 0 40 9 77 29 110 20 34 46 60 80 80 33 20 70 29 110 29 40 0 77-9 110-29 34-20 60-46 80-80 20-33 29-70 29-110z"/>
+</font></defs></svg>

data/app/assets/javascripts/slick.js

@@ -0,0 +1,1147 @@
+/*
+ slick.js
+ Author: Ken Wheeler
+ Date: 03/23/14
+ */
+/*global window, document, define, jQuery, setInterval, clearInterval */
+(function (factory) {
+    'use strict';
+    if (typeof define === 'function' && define.amd) {
+        define(['jquery'], factory);
+    } else {
+        factory(jQuery);
+    }
+
+}(function ($) {
+    'use strict';
+    var Slick = window.Slick || {}, functionBinder;
+
+    /************ Helpers ***********/
+
+    // Function Binder
+
+    functionBinder = function (fn, me) {
+        return function () {
+            return fn.apply(me, arguments);
+        };
+    };
+
+    /********** End Helpers *********/
+
+    Slick = (function () {
+
+        function Slick(element, settings) {
+
+            var _ = this, responsiveSettings, breakpoint;
+
+            _.defaults = {
+                autoplay: false,
+                autoplaySpeed: 3000,
+                dots: false,
+                draggable: true,
+                arrows: true,
+                infinite: true,
+                onBeforeChange: null,
+                onAfterChange: null,
+                pauseOnHover: true,
+                responsive: null,
+                slide: 'div',
+                slidesToShow: 1,
+                slidesToScroll: 1,
+                speed: 300,
+                swipe: true,
+                touchMove: true,
+                touchThreshold: 5
+            };
+
+            _.initials = {
+                animating : false,
+                autoPlayTimer : null,
+                currentSlide : 0,
+                currentLeft : null,
+                direction : 1,
+                dots : null,
+                listWidth : null,
+                loadIndex : 0,
+                nextArrow : null,
+                prevArrow : null,
+                slideCount : null,
+                slideWidth : null,
+                slideTrack : null,
+                slides : null,
+                sliding : false,
+                slideOffset : 0,
+                swipeLeft : null,
+                list : null,
+                touchObject : {},
+                transformsEnabled : false
+            };
+
+            $.extend(_, _.initials);
+
+            _.activeBreakpoint = null;
+            _.animType = null;
+            _.breakpoints = [];
+            _.breakpointSettings = [];
+            _.slider = $(element);
+
+            _.options = $.extend({}, _.defaults, settings);
+
+            _.originalSettings = _.options;
+            responsiveSettings = _.options.responsive ||
+                null;
+
+            if (responsiveSettings && responsiveSettings.length > -1) {
+                for (breakpoint in responsiveSettings) {
+                    if (responsiveSettings.hasOwnProperty(breakpoint)) {
+                        _.breakpoints.push(responsiveSettings[
+                            breakpoint].breakpoint);
+                        _.breakpointSettings[responsiveSettings[
+                            breakpoint].breakpoint] =
+                            responsiveSettings[breakpoint].settings;
+                    }
+                }
+                _.breakpoints.sort(function (a, b) {
+                    return b - a;
+                });
+            }
+
+            _.autoPlay = functionBinder(_.autoPlay,
+                _);
+            _.autoPlayClear = functionBinder(_.autoPlayClear,
+                _);
+            _.changeSlide = functionBinder(_.changeSlide,
+                _);
+            _.setPosition = functionBinder(_.setPosition,
+                _);
+            _.swipeHandler = functionBinder(_.swipeHandler,
+                _);
+            _.dragHandler = functionBinder(_.dragHandler,
+                _);
+            _.autoPlayIterator = functionBinder(_.autoPlayIterator,
+                _);
+
+            _.init();
+
+        }
+
+        return Slick;
+
+    }());
+
+    Slick.prototype.init = function () {
+
+        var _ = this;
+
+        if (!$(_.slider).hasClass('slick-initialized')) {
+
+            $(_.slider).addClass('slick-initialized');
+            _.buildOut();
+            _.getAnimType();
+            _.startLoad();
+            _.loadSlider();
+            _.initializeEvents();
+            _.checkResponsive();
+        }
+
+    };
+
+    Slick.prototype.getAnimType = function () {
+
+        var _ = this;
+
+        if (document.body.style.MozTransform !== undefined) {
+
+            _.animType = 'MozTransform';
+
+        } else if (document.body.style.webkitTransform !==
+            undefined) {
+
+            _.animType = "webkitTransform";
+
+        } else if (document.body.style.msTransform !==
+            undefined) {
+
+            _.animType = "msTransform";
+
+        }
+
+        if (_.animType !== null) {
+
+            _.transformsEnabled = true;
+
+        }
+
+    };
+
+    Slick.prototype.autoPlay = function () {
+
+        var _ = this;
+
+        if (_.autoPlayTimer) {
+
+            clearInterval(_.autoPlayTimer);
+
+        }
+
+        _.autoPlayTimer = setInterval(_.autoPlayIterator,
+            _.options.autoplaySpeed);
+
+    };
+
+    Slick.prototype.autoPlayClear = function () {
+
+        var _ = this;
+
+        if (_.autoPlayTimer) {
+            clearInterval(_.autoPlayTimer);
+        }
+
+    };
+
+    Slick.prototype.autoPlayIterator = function () {
+
+        var _ = this;
+
+        if (_.options.infinite === false) {
+
+            if (_.direction === 1) {
+
+                if ((_.currentSlide + 1) === _.slideCount -
+                    1) {
+                    _.direction = 0;
+                }
+
+                _.slideHandler(_.currentSlide + _.options
+                    .slidesToScroll);
+
+            } else {
+
+                if ((_.currentSlide - 1 === 0)) {
+
+                    _.direction = 1;
+
+                }
+
+                _.slideHandler(_.currentSlide - _.options
+                    .slidesToScroll);
+
+            }
+
+        } else {
+
+            _.slideHandler(_.currentSlide + _.options.slidesToScroll);
+
+        }
+
+    };
+
+    Slick.prototype.checkResponsive = function () {
+        var _ = this, breakpoint, targetBreakpoint;
+
+        if (_.originalSettings.responsive && _.originalSettings
+            .responsive.length > -1) {
+
+            targetBreakpoint = null;
+
+            for (breakpoint in _.breakpoints) {
+                if (_.breakpoints.hasOwnProperty(breakpoint)) {
+                    if ($(window).width() < _.breakpoints[
+                        breakpoint]) {
+                        targetBreakpoint = _.breakpoints[
+                            breakpoint];
+                    }
+                }
+            }
+
+            if (targetBreakpoint !== null) {
+                if (_.activeBreakpoint !== null) {
+                    if (targetBreakpoint !== _.activeBreakpoint) {
+                        _.activeBreakpoint =
+                            targetBreakpoint;
+                        _.options = $.extend({}, _.defaults,
+                            _.breakpointSettings[
+                                targetBreakpoint]);
+                            _.refresh();
+                    }
+                } else {
+                    _.activeBreakpoint = targetBreakpoint;
+                    _.options = $.extend({}, _.defaults,
+                        _.breakpointSettings[
+                            targetBreakpoint]);
+                        _.refresh();
+                }
+            } else {
+                if (_.activeBreakpoint !== null) {
+                    _.activeBreakpoint = null;
+                    _.options = $.extend({}, _.defaults,
+                        _.originalSettings);
+                        _.refresh();
+                }
+            }
+
+        }
+    };
+
+    Slick.prototype.startLoad = function () {
+
+        var _ = this;
+
+        if (_.options.arrows === true) {
+
+            _.prevArrow.hide();
+            _.nextArrow.hide();
+
+        }
+
+        if (_.options.dots === true) {
+
+            _.dots.hide();
+
+        }
+
+        _.slider.addClass('slick-loading');
+
+    };
+
+    Slick.prototype.initUI = function () {
+
+        var _ = this;
+
+        if (_.options.arrows === true) {
+
+            _.prevArrow.show();
+            _.nextArrow.show();
+
+        }
+
+        if (_.options.dots === true) {
+
+            _.dots.show();
+
+        }
+
+        if (_.options.autoplay === true) {
+
+            _.autoPlay();
+
+        }
+
+    };
+
+    Slick.prototype.loadSlider = function () {
+
+        var _ = this;
+
+        _.setPosition();
+
+        _.slideTrack.animate({
+            opacity: 1
+        }, _.options.speed, function () {
+            _.setPosition();
+        });
+
+        if (document.readyState !== "complete") {
+
+            $(window).load(function () {
+
+                _.slider.removeClass('slick-loading');
+
+                _.initUI();
+
+            });
+
+        } else {
+
+            _.slider.removeClass('slick-loading');
+
+            _.initUI();
+
+        }
+
+    };
+
+    Slick.prototype.setValues = function () {
+
+        var _ = this;
+
+        _.listWidth = _.list.width();
+        _.slideWidth = Math.ceil(_.listWidth / _.options
+            .slidesToShow);
+
+    };
+
+    Slick.prototype.buildArrows = function () {
+
+        var _ = this;
+
+        if (_.options.arrows === true) {
+
+            _.prevArrow = $(
+                '<a href="javascript:void(0)">Previous</a>').appendTo(
+                _.slider).addClass('slick-prev');
+            _.nextArrow = $(
+                '<a href="javascript:void(0)">Next</a>').appendTo(
+                _.slider).addClass('slick-next');
+
+            if (_.options.infinite !== true) {
+                _.prevArrow.addClass('slick-disabled');
+            }
+
+        }
+
+    };
+
+    Slick.prototype.buildDots = function () {
+
+        var _ = this, i, dotString;
+
+        if (_.options.dots === true) {
+
+            dotString = '<ul class="slick-dots">';
+
+            for (i = 1; i <= _.slideCount; i += 1) {
+
+                dotString += '<li><a href="javascript:void(0)">' + i +
+                    '</a></li>';
+
+            }
+
+            dotString += "</ul>";
+
+            _.dots = $(dotString).appendTo(
+                _.slider);
+
+            if (_.options.slidesToScroll > 1) {
+                _.dots.find('li').hide();
+                i = 0;
+                while (i < _.slideCount) {
+                    $(_.dots.find('li').get(i)).show();
+                    i = i + _.options.slidesToScroll;
+                }
+            }
+
+            _.dots.find('li').first().addClass(
+                'slick-active');
+
+        }
+
+    };
+
+    Slick.prototype.setupInfinite = function () {
+
+        var _ = this, i, slideIndex;
+
+        if (_.options.infinite === true) {
+
+            slideIndex = null;
+
+            for (i = _.slideCount; i > (_.slideCount -
+                _.options.slidesToShow); i -= 1) {
+                slideIndex = i - 1;
+                $(_.slides[slideIndex]).clone().prependTo(
+                    _.slideTrack).addClass('slick-cloned');
+            }
+            for (i = 0; i < _.options.slidesToShow; i += 1) {
+                slideIndex = i;
+                $(_.slides[slideIndex]).clone().appendTo(
+                    _.slideTrack).addClass('slick-cloned');
+            }
+
+        }
+
+    };
+
+    Slick.prototype.buildOut = function () {
+
+        var i, _ = this, placeholders;
+
+        _.slides = $(_.options.slide +
+            ':not(.slick-cloned)', _.slider).addClass(
+            'slick-slide');
+        _.slideCount = _.slides.length;
+        if ((_.slideCount % _.options.slidesToScroll) !==
+            0 && _.options.slidesToShow !== 1) {
+
+            placeholders = Math.abs(_.options.slidesToScroll -
+                (_.slideCount % _.options.slidesToScroll)
+            );
+            for (i = 0; i < placeholders; i += 1) {
+                $('<div/>').appendTo(_.slider).addClass(
+                    'slick-slide slick-placeholder');
+            }
+            _.slides = $('.slick-slide:not(.slick-cloned)',
+                _.slider);
+            _.slideCount = _.slides.length;
+
+        }
+
+        _.slider.addClass("slick-slider");
+        _.slideTrack = _.slides.wrapAll(
+            '<div class="slick-track"/>').parent();
+        _.list = _.slideTrack.wrap(
+            '<div class="slick-list"/>').parent();
+        _.slideTrack.css('opacity', 0);
+
+        _.buildArrows();
+
+        _.buildDots();
+
+        _.setupInfinite();
+
+        _.setSlideClasses(0);
+
+        if (_.options.draggable === true) {
+            _.list.addClass('draggable');
+        }
+
+    };
+
+    Slick.prototype.setDimensions = function () {
+        var _ = this;
+        _.slideWidth = Math.ceil(_.listWidth / _.options
+            .slidesToShow);
+        _.list.find('.slick-slide').width(_.slideWidth);
+        _.slideTrack.width(Math.ceil((_.slideWidth * _
+            .slider.find('.slick-slide').length)));
+    };
+
+    Slick.prototype.setPosition = function () {
+        var _ = this, animProps = {}, targetLeft;
+        _.setValues();
+        _.setDimensions();
+
+        if (_.options.infinite === true) {
+            _.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;
+        }
+
+        targetLeft = ((_.currentSlide *
+                _.slideWidth) * -1) + _.slideOffset;
+
+        if (_.transformsEnabled === false) {
+            _.slideTrack.css('left', targetLeft);
+        } else {
+            animProps[_.animType] = "translate(" +
+                targetLeft + "px, 0px)";
+            _.slideTrack.css(animProps);
+        }
+
+    };
+
+    Slick.prototype.initializeEvents = function () {
+
+        var _ = this;
+
+        if (_.options.arrows === true) {
+            _.prevArrow.on('click.slick', {
+                message: 'previous'
+            }, _.changeSlide);
+            _.nextArrow.on('click.slick', {
+                message: 'next'
+            }, _.changeSlide);
+        }
+
+        if (_.options.dots === true) {
+            $('li a', _.dots).on('click.slick', {
+                message: 'index'
+            }, _.changeSlide);
+        }
+
+        if (_.options.swipe === true) {
+            _.list.on('touchstart.slick', {
+                action: 'start',
+                kind: 'touch'
+            }, _.swipeHandler);
+            _.list.on('touchmove.slick', {
+                action: 'move',
+                kind: 'touch'
+            }, _.swipeHandler);
+            _.list.on('touchend.slick', {
+                action: 'end',
+                kind: 'touch'
+            }, _.swipeHandler);
+        }
+
+        if (_.options.draggable === true) {
+            _.list.on('mousedown.slick', {
+                action: 'start',
+                kind: 'drag'
+            }, _.swipeHandler);
+            _.list.on('mousemove.slick', {
+                action: 'move',
+                kind: 'drag'
+            }, _.swipeHandler);
+            _.list.on('mouseup.slick', {
+                action: 'end',
+                kind: 'drag'
+            }, _.swipeHandler);
+            _.list.on('mouseleave.slick', {
+                action: 'cancel',
+                kind: 'drag'
+            }, _.swipeHandler);
+        }
+
+        if (_.options.pauseOnHover === true && _.options.autoplay === true) {
+            _.list.on('mouseenter.slick', _.autoPlayClear);
+            _.list.on('mouseleave.slick', _.autoPlay);
+        }
+
+        $(window).on('orientationchange.slick', _.setPosition);
+
+        $(window).on('resize.slick', function () {
+            _.checkResponsive();
+            _.setPosition();
+        });
+
+        $(window).on('load.slick', _.setPosition);
+
+    };
+
+    Slick.prototype.changeSlide = function (event) {
+
+        var _ = this;
+
+        switch (event.data.message) {
+
+        case 'previous':
+            _.slideHandler(_.currentSlide - _.options
+                .slidesToScroll);
+            break;
+
+        case 'next':
+            _.slideHandler(_.currentSlide + _.options
+                .slidesToScroll);
+            break;
+
+        case 'index':
+            _.slideHandler($(event.target).parent().index());
+            break;
+
+        default:
+            return false;
+        }
+
+    };
+
+    Slick.prototype.updateDots = function () {
+
+        var _ = this;
+
+        if(_.dots !== null) {
+
+            _.dots.find('li').removeClass('slick-active');
+            $(_.dots.find('li').get(_.currentSlide)).addClass(
+                'slick-active');
+
+        }
+
+    };
+
+    Slick.prototype.animateSlide = function (targetLeft,
+        callback) {
+
+        var animProps = {}, _ = this;
+
+        if (_.options.onBeforeChange !== null) {
+            _.options.onBeforeChange.call();
+        }
+
+        if (_.transformsEnabled === false) {
+
+            _.slideTrack.animate({
+                left: targetLeft
+            }, _.options.speed, callback);
+
+        } else {
+
+            $({
+                animStart: _.currentLeft
+            }).animate({
+                animStart: targetLeft
+            }, {
+                duration: _.options.speed,
+                step: function (now) {
+                    animProps[_.animType] = "translate(" +
+                        now + "px, 0px)";
+                    _.slideTrack.css(animProps);
+                },
+                complete: function () {
+                    if (callback) {
+                        callback.call();
+                    }
+                }
+            });
+
+        }
+
+    };
+
+    Slick.prototype.setSlideClasses = function (index) {
+        var _ = this;
+        _.slides.removeClass('slick-active');
+        $(_.slides.get(index)).addClass('slick-active');
+    };
+
+    Slick.prototype.postSlide = function (index) {
+
+        var _ = this;
+
+        _.animating = false;
+
+        _.currentSlide = index;
+
+        _.setPosition();
+
+        _.swipeLeft = null;
+
+        _.updateDots();
+
+        if (_.options.autoplay === true) {
+            _.autoPlay();
+        }
+
+        if (_.options.onAfterChange !== null) {
+            _.options.onAfterChange.call();
+        }
+
+        if (_.options.arrows === true && _.options.infinite !==
+            true) {
+            if (_.currentSlide === 0) {
+                _.prevArrow.addClass('slick-disabled');
+                _.nextArrow.removeClass('slick-disabled');
+            } else if (_.currentSlide >= (_.slideCount /
+                _.options.slidesToScroll * _.options.slidesToShow
+            ) - _.options.slidesToScroll) {
+                _.nextArrow.addClass('slick-disabled');
+                _.prevArrow.removeClass('slick-disabled');
+            } else {
+                _.prevArrow.removeClass('slick-disabled');
+                _.nextArrow.removeClass('slick-disabled');
+            }
+        }
+
+        _.setSlideClasses(_.currentSlide);
+
+    };
+
+    Slick.prototype.slideHandler = function (index) {
+
+        var targetSlide, slideLeft, targetLeft =
+                null,
+            _ = this;
+
+        if(_.animating === true) {
+            return false;
+        }
+
+        targetSlide = index;
+        targetLeft = ((targetSlide * _.slideWidth) * -1) +
+            _.slideOffset;
+        slideLeft = ((_.currentSlide * _.slideWidth) * -1) +
+            _.slideOffset;
+
+        if (_.options.autoplay === true) {
+            clearInterval(_.autoPlayTimer);
+        }
+
+        if (_.swipeLeft === null) {
+            _.currentLeft = slideLeft;
+        } else {
+            _.currentLeft = _.swipeLeft;
+        }
+
+        if (targetSlide < 0) {
+
+            if (_.options.infinite === true) {
+
+                _.animating = true;
+
+                _.animateSlide(targetLeft, function () {
+
+                    _.postSlide(_.slideCount - _.options
+                        .slidesToScroll);
+
+                });
+
+            } else {
+
+                _.animateSlide(slideLeft);
+
+                return false;
+
+            }
+
+        } else if (targetSlide > (_.slideCount - 1)) {
+
+            if (_.options.infinite === true) {
+
+                _.animating = true;
+
+                _.animateSlide(targetLeft, function () {
+
+                    _.postSlide(0);
+
+                });
+
+            } else {
+
+                _.animateSlide(slideLeft);
+
+                return false;
+
+            }
+
+        } else {
+
+            _.animating = true;
+
+            _.animateSlide(targetLeft, function () {
+
+                _.postSlide(targetSlide);
+
+            });
+
+        }
+
+    };
+
+    Slick.prototype.swipeStart = function (event) {
+
+        var _ = this, touches;
+
+        touches = event.originalEvent.touches;
+
+        if (_.touchObject.fingerCount === 1 || event.data
+            .kind === 'drag') {
+
+            if (event.data.kind === 'touch') {
+                _.touchObject.startX = _.touchObject.
+                    curX =touches[0].pageX;
+                _.touchObject.startY = _.touchObject.
+                    curY =touches[0].pageY;
+            } else {
+                _.list.addClass('dragging');
+                _.touchObject.startX = _.touchObject.
+                    curX = event.clientX;
+                _.touchObject.startY = _.touchObject.
+                    curY = event.clientY;
+            }
+
+        } else {
+
+            _.touchObject = {};
+
+        }
+
+    };
+
+    Slick.prototype.swipeMove = function (event) {
+
+        var _ = this, animProps = {}, curLeft, newLeft = null, touches;
+
+        touches = event.originalEvent.touches;
+
+        curLeft = ((_.currentSlide * _.slideWidth) * -1) +
+            _.slideOffset;
+
+        if ((touches && touches.length === 1) || event.
+            data.kind ==='drag') {
+
+            if (event.data.kind === 'touch') {
+                _.touchObject.curX = touches[0].pageX;
+                _.touchObject.curY = touches[0].pageY;
+            } else {
+                _.touchObject.curX = event.clientX;
+                _.touchObject.curY = event.clientY;
+            }
+
+            _.touchObject.swipeLength = Math.round(Math.sqrt(
+                Math.pow(_.touchObject.curX - _.touchObject
+                    .startX, 2)));
+
+            if (_.swipeDirection() !== 'up' && _.swipeDirection() !==
+                'down') {
+
+                event.originalEvent.preventDefault();
+
+                if (_.touchObject.curX > _.touchObject
+                    .startX) {
+
+                    if (_.options.touchMove === true) {
+
+                        newLeft = curLeft + _.touchObject
+                            .swipeLength;
+                        if (_.transformsEnabled ===
+                            false) {
+                            _.slideTrack.css('left',
+                                newLeft);
+                        } else {
+                            animProps[_.animType] =
+                                "translate(" + newLeft +
+                                "px, 0px)";
+                            _.slideTrack.css(animProps);
+                            _.swipeLeft = newLeft;
+                        }
+
+                    }
+
+                } else {
+
+                    if (_.options.touchMove === true) {
+
+                        newLeft = curLeft - _.touchObject
+                            .swipeLength;
+                        if (_.transformsEnabled ===
+                            false) {
+                            _.slideTrack.css('left',
+                                newLeft);
+                        } else {
+                            animProps[_.animType] =
+                                "translate(" + newLeft +
+                                "px, 0px)";
+                            _.slideTrack.css(animProps);
+                            _.swipeLeft = newLeft;
+                        }
+
+                    }
+
+                }
+
+            }
+
+        } else {
+
+            _.touchObject = {};
+
+        }
+
+    };
+
+    Slick.prototype.swipeEnd = function (event) {
+
+        var _ = this;
+
+        if ((_.touchObject.fingerCount === 0 && _.touchObject
+            .curX !== 0) || event.data.kind === 'drag') {
+
+            if (_.touchObject.swipeLength >= _.touchObject
+                .minSwipe) {
+
+                switch (_.swipeDirection()) {
+
+                case 'left':
+
+                    _.slideHandler(_.currentSlide +
+                        _.options.slidesToScroll);
+                    _.touchObject = {};
+
+                    break;
+
+                case 'right':
+
+                    _.slideHandler(_.currentSlide -
+                        _.options.slidesToScroll);
+                    _.touchObject = {};
+
+                    break;
+
+                }
+
+            } else {
+
+                _.slideHandler(_.currentSlide);
+                _.touchObject = {};
+
+            }
+
+            if (event.data.kind === 'drag') {
+                _.list.removeClass('dragging');
+            }
+
+        } else {
+
+            _.touchObject = {};
+
+        }
+
+    };
+
+    Slick.prototype.swipeCancel = function () {
+
+        var _ = this;
+
+        _.list.removeClass('dragging');
+
+        if (_.touchObject.startX) {
+            _.slideHandler(_.currentSlide);
+            _.touchObject = {};
+        }
+
+    };
+
+    Slick.prototype.swipeHandler = function (event) {
+
+        var _ = this;
+
+        if (event.data.kind === 'touch') {
+            _.touchObject.fingerCount = event.originalEvent.touches
+                .length;
+        }
+
+        _.touchObject.minSwipe = _.slideWidth / _.options
+            .touchThreshold;
+
+        switch (event.data.action) {
+
+        case 'start':
+
+            _.swipeStart(event);
+
+            break;
+
+        case 'move':
+
+            _.swipeMove(event);
+
+            break;
+
+        case 'end':
+
+            _.swipeEnd(event);
+
+            break;
+
+        case 'cancel':
+
+            _.swipeCancel();
+
+            break;
+
+        }
+
+    };
+
+    Slick.prototype.swipeDirection = function () {
+
+        var xDist, yDist, r, swipeAngle, _ = this;
+
+        xDist = _.touchObject.startX - _.touchObject.curX;
+        yDist = _.touchObject.startY - _.touchObject.curY;
+        r = Math.atan2(yDist, xDist);
+
+        swipeAngle = Math.round(r * 180 / Math.PI);
+        if (swipeAngle < 0) {
+            swipeAngle = 360 - Math.abs(swipeAngle);
+        }
+
+        if ((swipeAngle <= 45) && (swipeAngle >= 0)) {
+            return 'left';
+        }
+        if ((swipeAngle <= 360) && (swipeAngle >= 315)) {
+            return 'left';
+        }
+        if ((swipeAngle >= 135) && (swipeAngle <= 225)) {
+            return 'right';
+        }
+        if ((swipeAngle > 45) && (swipeAngle < 135)) {
+            return 'down';
+        }
+
+        return 'up';
+
+    };
+
+    Slick.prototype.refresh = function () {
+
+        var _ = this;
+
+        _.destroy();
+
+        $.extend(_, _.initials);
+
+        _.init();
+
+    };
+
+    Slick.prototype.destroy = function () {
+        var _ = this;
+        $('.slick-cloned', _.slider).remove();
+        $('.slick-placeholder', _.slider).remove();
+        if (_.dots) {
+            _.dots.remove();
+        }
+        if (_.prevArrow) {
+            _.prevArrow.remove();
+            _.nextArrow.remove();
+        }
+        _.slides.unwrap().unwrap();
+        _.slides.removeClass(
+            'slick-slide slick-active slick-visible').width('');
+        _.slider.removeClass('slick-slider');
+        _.slider.removeClass('slick-initialized');
+    };
+
+    $.fn.slick = function (options) {
+        var _ = this;
+        return _.each(function (index, element) {
+
+            element.slick = new Slick(element, options);
+
+        });
+    };
+
+    $.fn.slickGoTo = function (slide) {
+        var _ = this;
+        return _.each(function (index, element) {
+
+           element.slick.slideHandler(slide);
+
+        });
+    };
+
+    $.fn.slickNext = function () {
+        var _ = this;
+        return _.each(function (index, element) {
+
+           element.slick.changeSlide({data: {message: 'next'}});
+
+        });
+    };
+
+    $.fn.slickPrev = function () {
+        var _ = this;
+        return _.each(function (index, element) {
+
+           element.slick.changeSlide({data: {message: 'previous'}});
+
+        });
+    };
+
+    $.fn.slickPause = function () {
+        var _ = this;
+        return _.each(function (index, element) {
+
+           element.slick.autoPlayClear();
+
+        });
+    };
+
+    $.fn.slickPlay = function () {
+        var _ = this;
+        return _.each(function (index, element) {
+
+           element.slick.autoPlay();
+
+        });
+    };
+
+    $.fn.unslick = function () {
+        var _ = this;
+        return _.each(function (index, element) {
+
+            element.slick.destroy();
+
+        });
+    };
+
+}));