API tools faq
paste
Frank786

JS Script Imporatnt Plugin.JS

Frank786
Nov 4th, 2017
67
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
4CS 127.34 KB | None | 0 0
raw download clone embed print report
  1. jQuery(document).ready(function($){
  2.   var slidesWrapper = $('.cd-hero-slider');
  3.  
  4.   //check if a .cd-hero-slider exists in the DOM
  5.   if ( slidesWrapper.length > 0 ) {
  6.     var primaryNav = $('.cd-primary-nav'),
  7.       sliderNav = $('.cd-slider-nav'),
  8.       navigationMarker = $('.cd-marker'),
  9.       slidesNumber = slidesWrapper.children('li').length,
  10.       visibleSlidePosition = 0,
  11.       autoPlayId,
  12.       autoPlayDelay = 5000;
  13.  
  14.     //upload videos (if not on mobile devices)
  15.     uploadVideo(slidesWrapper);
  16.  
  17.     //autoplay slider
  18.     setAutoplay(slidesWrapper, slidesNumber, autoPlayDelay);
  19.  
  20.     //on mobile - open/close primary navigation clicking/tapping the menu icon
  21.     primaryNav.on('click', function(event){
  22.       if($(event.target).is('.cd-primary-nav')) $(this).children('ul').toggleClass('is-visible');
  23.     });
  24.    
  25.     //change visible slide
  26.     sliderNav.on('click', 'li', function(event){
  27.       event.preventDefault();
  28.       var selectedItem = $(this);
  29.       if(!selectedItem.hasClass('selected')) {
  30.         // if it's not already selected
  31.         var selectedPosition = selectedItem.index(),
  32.           activePosition = slidesWrapper.find('li.selected').index();
  33.        
  34.         if( activePosition < selectedPosition) {
  35.           nextSlide(slidesWrapper.find('.selected'), slidesWrapper, sliderNav, selectedPosition);
  36.         } else {
  37.           prevSlide(slidesWrapper.find('.selected'), slidesWrapper, sliderNav, selectedPosition);
  38.         }
  39.  
  40.         //this is used for the autoplay
  41.         visibleSlidePosition = selectedPosition;
  42.  
  43.         updateSliderNavigation(sliderNav, selectedPosition);
  44.         updateNavigationMarker(navigationMarker, selectedPosition+1);
  45.         //reset autoplay
  46.         setAutoplay(slidesWrapper, slidesNumber, autoPlayDelay);
  47.       }
  48.     });
  49.   }
  50.  
  51.   function nextSlide(visibleSlide, container, pagination, n){
  52.     visibleSlide.removeClass('selected from-left from-right').addClass('is-moving').one('webkitTransitionEnd otransitionend oTransitionEnd msTransitionEnd transitionend', function(){
  53.       visibleSlide.removeClass('is-moving');
  54.     });
  55.  
  56.     container.children('li').eq(n).addClass('selected from-right').prevAll().addClass('move-left');
  57.     checkVideo(visibleSlide, container, n);
  58.   }
  59.  
  60.   function prevSlide(visibleSlide, container, pagination, n){
  61.     visibleSlide.removeClass('selected from-left from-right').addClass('is-moving').one('webkitTransitionEnd otransitionend oTransitionEnd msTransitionEnd transitionend', function(){
  62.       visibleSlide.removeClass('is-moving');
  63.     });
  64.  
  65.     container.children('li').eq(n).addClass('selected from-left').removeClass('move-left').nextAll().removeClass('move-left');
  66.     checkVideo(visibleSlide, container, n);
  67.   }
  68.  
  69.   function updateSliderNavigation(pagination, n) {
  70.     var navigationDot = pagination.find('.selected');
  71.     navigationDot.removeClass('selected');
  72.     pagination.find('li').eq(n).addClass('selected');
  73.   }
  74.  
  75.   function setAutoplay(wrapper, length, delay) {
  76.     if(wrapper.hasClass('autoplay')) {
  77.       clearInterval(autoPlayId);
  78.       autoPlayId = window.setInterval(function(){autoplaySlider(length)}, delay);
  79.     }
  80.   }
  81.  
  82.   function autoplaySlider(length) {
  83.     if( visibleSlidePosition < length - 1) {
  84.       nextSlide(slidesWrapper.find('.selected'), slidesWrapper, sliderNav, visibleSlidePosition + 1);
  85.       visibleSlidePosition +=1;
  86.     } else {
  87.       prevSlide(slidesWrapper.find('.selected'), slidesWrapper, sliderNav, 0);
  88.       visibleSlidePosition = 0;
  89.     }
  90.     updateNavigationMarker(navigationMarker, visibleSlidePosition+1);
  91.     updateSliderNavigation(sliderNav, visibleSlidePosition);
  92.   }
  93.  
  94.   function uploadVideo(container) {
  95.     container.find('.cd-bg-video-wrapper').each(function(){
  96.       var videoWrapper = $(this);
  97.       if( videoWrapper.is(':visible') ) {
  98.         // if visible - we are not on a mobile device
  99.         var videoUrl = videoWrapper.data('video'),
  100.           video = $('<video loop><source src="'+videoUrl+'.mp4" type="video/mp4" /><source src="'+videoUrl+'.webm" type="video/webm" /></video>');
  101.         video.appendTo(videoWrapper);
  102.         // play video if first slide
  103.         if(videoWrapper.parent('.cd-bg-video.selected').length > 0) video.get(0).play();
  104.       }
  105.     });
  106.   }
  107.  
  108.   function checkVideo(hiddenSlide, container, n) {
  109.     //check if a video outside the viewport is playing - if yes, pause it
  110.     var hiddenVideo = hiddenSlide.find('video');
  111.     if( hiddenVideo.length > 0 ) hiddenVideo.get(0).pause();
  112.  
  113.     //check if the select slide contains a video element - if yes, play the video
  114.     var visibleVideo = container.children('li').eq(n).find('video');
  115.     if( visibleVideo.length > 0 ) visibleVideo.get(0).play();
  116.   }
  117.  
  118.   function updateNavigationMarker(marker, n) {
  119.     marker.removeClassPrefix('item').addClass('item-'+n);
  120.   }
  121.  
  122.   $.fn.removeClassPrefix = function(prefix) {
  123.     //remove all classes starting with 'prefix'
  124.       this.each(function(i, el) {
  125.           var classes = el.className.split(" ").filter(function(c) {
  126.               return c.lastIndexOf(prefix, 0) !== 0;
  127.           });
  128.           el.className = $.trim(classes.join(" "));
  129.       });
  130.       return this;
  131.   };
  132. });
  133. /*!
  134.  * Lightbox v2.9.0
  135.  * by Lokesh Dhakar
  136.  *
  137.  * More info:
  138.  * http://lokeshdhakar.com/projects/lightbox2/
  139.  *
  140.  * Copyright 2007, 2015 Lokesh Dhakar
  141.  * Released under the MIT license
  142.  * https://github.com/lokesh/lightbox2/blob/master/LICENSE
  143.  */
  144.  
  145. // Uses Node, AMD or browser globals to create a module.
  146. (function (root, factory) {
  147.     if (typeof define === 'function' && define.amd) {
  148.         // AMD. Register as an anonymous module.
  149.         define(['jquery'], factory);
  150.     } else if (typeof exports === 'object') {
  151.         // Node. Does not work with strict CommonJS, but
  152.         // only CommonJS-like environments that support module.exports,
  153.         // like Node.
  154.         module.exports = factory(require('jquery'));
  155.     } else {
  156.         // Browser globals (root is window)
  157.         root.lightbox = factory(root.jQuery);
  158.     }
  159. }(this, function ($) {
  160.  
  161.   function Lightbox(options) {
  162.     this.album = [];
  163.     this.currentImageIndex = void 0;
  164.     this.init();
  165.  
  166.     // options
  167.     this.options = $.extend({}, this.constructor.defaults);
  168.     this.option(options);
  169.   }
  170.  
  171.   // Descriptions of all options available on the demo site:
  172.   // http://lokeshdhakar.com/projects/lightbox2/index.html#options
  173.   Lightbox.defaults = {
  174.     albumLabel: 'Image %1 of %2',
  175.     alwaysShowNavOnTouchDevices: false,
  176.     fadeDuration: 600,
  177.     fitImagesInViewport: true,
  178.     imageFadeDuration: 600,
  179.     // maxWidth: 800,
  180.     // maxHeight: 600,
  181.     positionFromTop: 50,
  182.     resizeDuration: 700,
  183.     showImageNumberLabel: true,
  184.     wrapAround: false,
  185.     disableScrolling: false,
  186.     /*
  187.     Sanitize Title
  188.     If the caption data is trusted, for example you are hardcoding it in, then leave this to false.
  189.     This will free you to add html tags, such as links, in the caption.
  190.  
  191.     If the caption data is user submitted or from some other untrusted source, then set this to true
  192.     to prevent xss and other injection attacks.
  193.      */
  194.     sanitizeTitle: false
  195.   };
  196.  
  197.   Lightbox.prototype.option = function(options) {
  198.     $.extend(this.options, options);
  199.   };
  200.  
  201.   Lightbox.prototype.imageCountLabel = function(currentImageNum, totalImages) {
  202.     return this.options.albumLabel.replace(/%1/g, currentImageNum).replace(/%2/g, totalImages);
  203.   };
  204.  
  205.   Lightbox.prototype.init = function() {
  206.     var self = this;
  207.     // Both enable and build methods require the body tag to be in the DOM.
  208.     $(document).ready(function() {
  209.       self.enable();
  210.       self.build();
  211.     });
  212.   };
  213.  
  214.   // Loop through anchors and areamaps looking for either data-lightbox attributes or rel attributes
  215.   // that contain 'lightbox'. When these are clicked, start lightbox.
  216.   Lightbox.prototype.enable = function() {
  217.     var self = this;
  218.     $('body').on('click', 'a[rel^=lightbox], area[rel^=lightbox], a[data-lightbox], area[data-lightbox]', function(event) {
  219.       self.start($(event.currentTarget));
  220.       return false;
  221.     });
  222.   };
  223.  
  224.   // Build html for the lightbox and the overlay.
  225.   // Attach event handlers to the new DOM elements. click click click
  226.   Lightbox.prototype.build = function() {
  227.     var self = this;
  228.     $('<div id="lightboxOverlay" class="lightboxOverlay"></div><div id="lightbox" class="lightbox"><div class="lb-outerContainer"><div class="lb-container"><img class="lb-image" src="data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==" /><div class="lb-nav"><a class="lb-prev" href="" ></a><a class="lb-next" href="" ></a></div><div class="lb-loader"><a class="lb-cancel"></a></div></div></div><div class="lb-dataContainer"><div class="lb-data"><div class="lb-details"><span class="lb-caption"></span><span class="lb-number"></span></div><div class="lb-closeContainer"><a class="lb-close"></a></div></div></div></div>').appendTo($('body'));
  229.  
  230.     // Cache jQuery objects
  231.     this.$lightbox       = $('#lightbox');
  232.     this.$overlay        = $('#lightboxOverlay');
  233.     this.$outerContainer = this.$lightbox.find('.lb-outerContainer');
  234.     this.$container      = this.$lightbox.find('.lb-container');
  235.     this.$image          = this.$lightbox.find('.lb-image');
  236.     this.$nav            = this.$lightbox.find('.lb-nav');
  237.  
  238.     // Store css values for future lookup
  239.     this.containerPadding = {
  240.       top: parseInt(this.$container.css('padding-top'), 10),
  241.       right: parseInt(this.$container.css('padding-right'), 10),
  242.       bottom: parseInt(this.$container.css('padding-bottom'), 10),
  243.       left: parseInt(this.$container.css('padding-left'), 10)
  244.     };
  245.  
  246.     this.imageBorderWidth = {
  247.       top: parseInt(this.$image.css('border-top-width'), 10),
  248.       right: parseInt(this.$image.css('border-right-width'), 10),
  249.       bottom: parseInt(this.$image.css('border-bottom-width'), 10),
  250.       left: parseInt(this.$image.css('border-left-width'), 10)
  251.     };
  252.  
  253.     // Attach event handlers to the newly minted DOM elements
  254.     this.$overlay.hide().on('click', function() {
  255.       self.end();
  256.       return false;
  257.     });
  258.  
  259.     this.$lightbox.hide().on('click', function(event) {
  260.       if ($(event.target).attr('id') === 'lightbox') {
  261.         self.end();
  262.       }
  263.       return false;
  264.     });
  265.  
  266.     this.$outerContainer.on('click', function(event) {
  267.       if ($(event.target).attr('id') === 'lightbox') {
  268.         self.end();
  269.       }
  270.       return false;
  271.     });
  272.  
  273.     this.$lightbox.find('.lb-prev').on('click', function() {
  274.       if (self.currentImageIndex === 0) {
  275.         self.changeImage(self.album.length - 1);
  276.       } else {
  277.         self.changeImage(self.currentImageIndex - 1);
  278.       }
  279.       return false;
  280.     });
  281.  
  282.     this.$lightbox.find('.lb-next').on('click', function() {
  283.       if (self.currentImageIndex === self.album.length - 1) {
  284.         self.changeImage(0);
  285.       } else {
  286.         self.changeImage(self.currentImageIndex + 1);
  287.       }
  288.       return false;
  289.     });
  290.  
  291.     /*
  292.       Show context menu for image on right-click
  293.  
  294.       There is a div containing the navigation that spans the entire image and lives above of it. If
  295.       you right-click, you are right clicking this div and not the image. This prevents users from
  296.       saving the image or using other context menu actions with the image.
  297.  
  298.       To fix this, when we detect the right mouse button is pressed down, but not yet clicked, we
  299.       set pointer-events to none on the nav div. This is so that the upcoming right-click event on
  300.       the next mouseup will bubble down to the image. Once the right-click/contextmenu event occurs
  301.       we set the pointer events back to auto for the nav div so it can capture hover and left-click
  302.       events as usual.
  303.      */
  304.     this.$nav.on('mousedown', function(event) {
  305.       if (event.which === 3) {
  306.         self.$nav.css('pointer-events', 'none');
  307.  
  308.         self.$lightbox.one('contextmenu', function() {
  309.           setTimeout(function() {
  310.               this.$nav.css('pointer-events', 'auto');
  311.           }.bind(self), 0);
  312.         });
  313.       }
  314.     });
  315.  
  316.  
  317.     this.$lightbox.find('.lb-loader, .lb-close').on('click', function() {
  318.       self.end();
  319.       return false;
  320.     });
  321.   };
  322.  
  323.   // Show overlay and lightbox. If the image is part of a set, add siblings to album array.
  324.   Lightbox.prototype.start = function($link) {
  325.     var self    = this;
  326.     var $window = $(window);
  327.  
  328.     $window.on('resize', $.proxy(this.sizeOverlay, this));
  329.  
  330.     $('select, object, embed').css({
  331.       visibility: 'hidden'
  332.     });
  333.  
  334.     this.sizeOverlay();
  335.  
  336.     this.album = [];
  337.     var imageNumber = 0;
  338.  
  339.     function addToAlbum($link) {
  340.       self.album.push({
  341.         link: $link.attr('href'),
  342.         title: $link.attr('data-title') || $link.attr('title')
  343.       });
  344.     }
  345.  
  346.     // Support both data-lightbox attribute and rel attribute implementations
  347.     var dataLightboxValue = $link.attr('data-lightbox');
  348.     var $links;
  349.  
  350.     if (dataLightboxValue) {
  351.       $links = $($link.prop('tagName') + '[data-lightbox="' + dataLightboxValue + '"]');
  352.       for (var i = 0; i < $links.length; i = ++i) {
  353.         addToAlbum($($links[i]));
  354.         if ($links[i] === $link[0]) {
  355.           imageNumber = i;
  356.         }
  357.       }
  358.     } else {
  359.       if ($link.attr('rel') === 'lightbox') {
  360.         // If image is not part of a set
  361.         addToAlbum($link);
  362.       } else {
  363.         // If image is part of a set
  364.         $links = $($link.prop('tagName') + '[rel="' + $link.attr('rel') + '"]');
  365.         for (var j = 0; j < $links.length; j = ++j) {
  366.           addToAlbum($($links[j]));
  367.           if ($links[j] === $link[0]) {
  368.             imageNumber = j;
  369.           }
  370.         }
  371.       }
  372.     }
  373.  
  374.     // Position Lightbox
  375.     var top  = $window.scrollTop() + this.options.positionFromTop;
  376.     var left = $window.scrollLeft();
  377.     this.$lightbox.css({
  378.       top: top + 'px',
  379.       left: left + 'px'
  380.     }).fadeIn(this.options.fadeDuration);
  381.  
  382.     // Disable scrolling of the page while open
  383.     if (this.options.disableScrolling) {
  384.       $('body').addClass('lb-disable-scrolling');
  385.     }
  386.  
  387.     this.changeImage(imageNumber);
  388.   };
  389.  
  390.   // Hide most UI elements in preparation for the animated resizing of the lightbox.
  391.   Lightbox.prototype.changeImage = function(imageNumber) {
  392.     var self = this;
  393.  
  394.     this.disableKeyboardNav();
  395.     var $image = this.$lightbox.find('.lb-image');
  396.  
  397.     this.$overlay.fadeIn(this.options.fadeDuration);
  398.  
  399.     $('.lb-loader').fadeIn('slow');
  400.     this.$lightbox.find('.lb-image, .lb-nav, .lb-prev, .lb-next, .lb-dataContainer, .lb-numbers, .lb-caption').hide();
  401.  
  402.     this.$outerContainer.addClass('animating');
  403.  
  404.     // When image to show is preloaded, we send the width and height to sizeContainer()
  405.     var preloader = new Image();
  406.     preloader.onload = function() {
  407.       var $preloader;
  408.       var imageHeight;
  409.       var imageWidth;
  410.       var maxImageHeight;
  411.       var maxImageWidth;
  412.       var windowHeight;
  413.       var windowWidth;
  414.  
  415.       $image.attr('src', self.album[imageNumber].link);
  416.  
  417.       $preloader = $(preloader);
  418.  
  419.       $image.width(preloader.width);
  420.       $image.height(preloader.height);
  421.  
  422.       if (self.options.fitImagesInViewport) {
  423.         // Fit image inside the viewport.
  424.         // Take into account the border around the image and an additional 10px gutter on each side.
  425.  
  426.         windowWidth    = $(window).width();
  427.         windowHeight   = $(window).height();
  428.         maxImageWidth  = windowWidth - self.containerPadding.left - self.containerPadding.right - self.imageBorderWidth.left - self.imageBorderWidth.right - 20;
  429.         maxImageHeight = windowHeight - self.containerPadding.top - self.containerPadding.bottom - self.imageBorderWidth.top - self.imageBorderWidth.bottom - 120;
  430.  
  431.         // Check if image size is larger then maxWidth|maxHeight in settings
  432.         if (self.options.maxWidth && self.options.maxWidth < maxImageWidth) {
  433.           maxImageWidth = self.options.maxWidth;
  434.         }
  435.         if (self.options.maxHeight && self.options.maxHeight < maxImageWidth) {
  436.           maxImageHeight = self.options.maxHeight;
  437.         }
  438.  
  439.         // Is there a fitting issue?
  440.         if ((preloader.width > maxImageWidth) || (preloader.height > maxImageHeight)) {
  441.           if ((preloader.width / maxImageWidth) > (preloader.height / maxImageHeight)) {
  442.             imageWidth  = maxImageWidth;
  443.             imageHeight = parseInt(preloader.height / (preloader.width / imageWidth), 10);
  444.             $image.width(imageWidth);
  445.             $image.height(imageHeight);
  446.           } else {
  447.             imageHeight = maxImageHeight;
  448.             imageWidth = parseInt(preloader.width / (preloader.height / imageHeight), 10);
  449.             $image.width(imageWidth);
  450.             $image.height(imageHeight);
  451.           }
  452.         }
  453.       }
  454.       self.sizeContainer($image.width(), $image.height());
  455.     };
  456.  
  457.     preloader.src          = this.album[imageNumber].link;
  458.     this.currentImageIndex = imageNumber;
  459.   };
  460.  
  461.   // Stretch overlay to fit the viewport
  462.   Lightbox.prototype.sizeOverlay = function() {
  463.     this.$overlay
  464.       .width($(document).width())
  465.       .height($(document).height());
  466.   };
  467.  
  468.   // Animate the size of the lightbox to fit the image we are showing
  469.   Lightbox.prototype.sizeContainer = function(imageWidth, imageHeight) {
  470.     var self = this;
  471.  
  472.     var oldWidth  = this.$outerContainer.outerWidth();
  473.     var oldHeight = this.$outerContainer.outerHeight();
  474.     var newWidth  = imageWidth + this.containerPadding.left + this.containerPadding.right + this.imageBorderWidth.left + this.imageBorderWidth.right;
  475.     var newHeight = imageHeight + this.containerPadding.top + this.containerPadding.bottom + this.imageBorderWidth.top + this.imageBorderWidth.bottom;
  476.  
  477.     function postResize() {
  478.       self.$lightbox.find('.lb-dataContainer').width(newWidth);
  479.       self.$lightbox.find('.lb-prevLink').height(newHeight);
  480.       self.$lightbox.find('.lb-nextLink').height(newHeight);
  481.       self.showImage();
  482.     }
  483.  
  484.     if (oldWidth !== newWidth || oldHeight !== newHeight) {
  485.       this.$outerContainer.animate({
  486.         width: newWidth,
  487.         height: newHeight
  488.       }, this.options.resizeDuration, 'swing', function() {
  489.         postResize();
  490.       });
  491.     } else {
  492.       postResize();
  493.     }
  494.   };
  495.  
  496.   // Display the image and its details and begin preload neighboring images.
  497.   Lightbox.prototype.showImage = function() {
  498.     this.$lightbox.find('.lb-loader').stop(true).hide();
  499.     this.$lightbox.find('.lb-image').fadeIn(this.options.imageFadeDuration);
  500.  
  501.     this.updateNav();
  502.     this.updateDetails();
  503.     this.preloadNeighboringImages();
  504.     this.enableKeyboardNav();
  505.   };
  506.  
  507.   // Display previous and next navigation if appropriate.
  508.   Lightbox.prototype.updateNav = function() {
  509.     // Check to see if the browser supports touch events. If so, we take the conservative approach
  510.     // and assume that mouse hover events are not supported and always show prev/next navigation
  511.     // arrows in image sets.
  512.     var alwaysShowNav = false;
  513.     try {
  514.       document.createEvent('TouchEvent');
  515.       alwaysShowNav = (this.options.alwaysShowNavOnTouchDevices) ? true : false;
  516.     } catch (e) {}
  517.  
  518.     this.$lightbox.find('.lb-nav').show();
  519.  
  520.     if (this.album.length > 1) {
  521.       if (this.options.wrapAround) {
  522.         if (alwaysShowNav) {
  523.           this.$lightbox.find('.lb-prev, .lb-next').css('opacity', '1');
  524.         }
  525.         this.$lightbox.find('.lb-prev, .lb-next').show();
  526.       } else {
  527.         if (this.currentImageIndex > 0) {
  528.           this.$lightbox.find('.lb-prev').show();
  529.           if (alwaysShowNav) {
  530.             this.$lightbox.find('.lb-prev').css('opacity', '1');
  531.           }
  532.         }
  533.         if (this.currentImageIndex < this.album.length - 1) {
  534.           this.$lightbox.find('.lb-next').show();
  535.           if (alwaysShowNav) {
  536.             this.$lightbox.find('.lb-next').css('opacity', '1');
  537.           }
  538.         }
  539.       }
  540.     }
  541.   };
  542.  
  543.   // Display caption, image number, and closing button.
  544.   Lightbox.prototype.updateDetails = function() {
  545.     var self = this;
  546.  
  547.     // Enable anchor clicks in the injected caption html.
  548.     // Thanks Nate Wright for the fix. @https://github.com/NateWr
  549.     if (typeof this.album[this.currentImageIndex].title !== 'undefined' &&
  550.       this.album[this.currentImageIndex].title !== '') {
  551.       var $caption = this.$lightbox.find('.lb-caption');
  552.       if (this.options.sanitizeTitle) {
  553.         $caption.text(this.album[this.currentImageIndex].title);
  554.       } else {
  555.         $caption.html(this.album[this.currentImageIndex].title);
  556.       }
  557.       $caption.fadeIn('fast')
  558.         .find('a').on('click', function(event) {
  559.           if ($(this).attr('target') !== undefined) {
  560.             window.open($(this).attr('href'), $(this).attr('target'));
  561.           } else {
  562.             location.href = $(this).attr('href');
  563.           }
  564.         });
  565.     }
  566.  
  567.     if (this.album.length > 1 && this.options.showImageNumberLabel) {
  568.       var labelText = this.imageCountLabel(this.currentImageIndex + 1, this.album.length);
  569.       this.$lightbox.find('.lb-number').text(labelText).fadeIn('fast');
  570.     } else {
  571.       this.$lightbox.find('.lb-number').hide();
  572.     }
  573.  
  574.     this.$outerContainer.removeClass('animating');
  575.  
  576.     this.$lightbox.find('.lb-dataContainer').fadeIn(this.options.resizeDuration, function() {
  577.       return self.sizeOverlay();
  578.     });
  579.   };
  580.  
  581.   // Preload previous and next images in set.
  582.   Lightbox.prototype.preloadNeighboringImages = function() {
  583.     if (this.album.length > this.currentImageIndex + 1) {
  584.       var preloadNext = new Image();
  585.       preloadNext.src = this.album[this.currentImageIndex + 1].link;
  586.     }
  587.     if (this.currentImageIndex > 0) {
  588.       var preloadPrev = new Image();
  589.       preloadPrev.src = this.album[this.currentImageIndex - 1].link;
  590.     }
  591.   };
  592.  
  593.   Lightbox.prototype.enableKeyboardNav = function() {
  594.     $(document).on('keyup.keyboard', $.proxy(this.keyboardAction, this));
  595.   };
  596.  
  597.   Lightbox.prototype.disableKeyboardNav = function() {
  598.     $(document).off('.keyboard');
  599.   };
  600.  
  601.   Lightbox.prototype.keyboardAction = function(event) {
  602.     var KEYCODE_ESC        = 27;
  603.     var KEYCODE_LEFTARROW  = 37;
  604.     var KEYCODE_RIGHTARROW = 39;
  605.  
  606.     var keycode = event.keyCode;
  607.     var key     = String.fromCharCode(keycode).toLowerCase();
  608.     if (keycode === KEYCODE_ESC || key.match(/x|o|c/)) {
  609.       this.end();
  610.     } else if (key === 'p' || keycode === KEYCODE_LEFTARROW) {
  611.       if (this.currentImageIndex !== 0) {
  612.         this.changeImage(this.currentImageIndex - 1);
  613.       } else if (this.options.wrapAround && this.album.length > 1) {
  614.         this.changeImage(this.album.length - 1);
  615.       }
  616.     } else if (key === 'n' || keycode === KEYCODE_RIGHTARROW) {
  617.       if (this.currentImageIndex !== this.album.length - 1) {
  618.         this.changeImage(this.currentImageIndex + 1);
  619.       } else if (this.options.wrapAround && this.album.length > 1) {
  620.         this.changeImage(0);
  621.       }
  622.     }
  623.   };
  624.  
  625.   // Closing time. :-(
  626.   Lightbox.prototype.end = function() {
  627.     this.disableKeyboardNav();
  628.     $(window).off('resize', this.sizeOverlay);
  629.     this.$lightbox.fadeOut(this.options.fadeDuration);
  630.     this.$overlay.fadeOut(this.options.fadeDuration);
  631.     $('select, object, embed').css({
  632.       visibility: 'visible'
  633.     });
  634.     if (this.options.disableScrolling) {
  635.       $('body').removeClass('lb-disable-scrolling');
  636.     }
  637.   };
  638.  
  639.   return new Lightbox();
  640. }));
  641.  
  642.  
  643. /*
  644. * MIXITUP - A CSS3 and JQuery Filter & Sort Plugin
  645. * Version: 1.5.5
  646. * License: Creative Commons Attribution-NoDerivs 3.0 Unported - CC BY-ND 3.0
  647. * http://creativecommons.org/licenses/by-nd/3.0/
  648. * This software may be used freely on commercial and non-commercial projects with attribution to the author/copyright holder.
  649. * Author: Patrick Kunka
  650. * Copyright 2012-2013 Patrick Kunka, Barrel LLC, All Rights Reserved
  651. *
  652. * http://mixitup.io
  653. */
  654.  
  655. (function($){
  656.    
  657.     // DECLARE METHODS
  658.  
  659.     var methods = {
  660.  
  661.         // "INIT" METHOD
  662.    
  663.         init: function(settings){
  664.  
  665.             return this.each(function(){
  666.                
  667.                 var browser = window.navigator.appVersion.match(/Chrome\/(\d+)\./),
  668.                     ver = browser ? parseInt(browser[1], 10) : false,
  669.                     chromeFix = function(id){
  670.                         var grid = document.getElementById(id),
  671.                             parent = grid.parentElement,
  672.                             placeholder = document.createElement('div'),
  673.                             frag = document.createDocumentFragment();
  674.  
  675.                         parent.insertBefore(placeholder, grid);  
  676.                         frag.appendChild(grid);
  677.                         parent.replaceChild(grid, placeholder);
  678.                         frag = null;
  679.                         placeholder = null;
  680.                     };
  681.                
  682.                 if(ver && ver == 31 || ver == 32){
  683.                     chromeFix(this.id);
  684.                 };
  685.                
  686.                 // BUILD CONFIG OBJECT
  687.  
  688.                 var config = {
  689.                    
  690.                     // PUBLIC PROPERTIES
  691.                    
  692.                     targetSelector : '.mix',
  693.                     filterSelector : '.filter',
  694.                     sortSelector : '.sort',
  695.                     buttonEvent: 'click',
  696.                     effects : ['fade', 'scale'],
  697.                     listEffects : null,
  698.                     easing : 'smooth',
  699.                     layoutMode: 'grid',
  700.                     targetDisplayGrid : 'inline-block',
  701.                     targetDisplayList: 'block',
  702.                     listClass : '',
  703.                     gridClass : '',
  704.                     transitionSpeed : 600,
  705.                     showOnLoad : 'all',
  706.                     sortOnLoad : false,
  707.                     multiFilter : false,
  708.                     filterLogic : 'or',
  709.                     resizeContainer : true,
  710.                     minHeight : 0,
  711.                     failClass : 'fail',
  712.                     perspectiveDistance : '3000',
  713.                     perspectiveOrigin : '50% 50%',
  714.                     animateGridList : true,
  715.                     onMixLoad: null,
  716.                     onMixStart : null,
  717.                     onMixEnd : null,
  718.  
  719.                     // MISC
  720.  
  721.                     container : null,
  722.                     origOrder : [],
  723.                     startOrder : [],
  724.                     newOrder : [],
  725.                     origSort: [],
  726.                     checkSort: [],
  727.                     filter : '',
  728.                     mixing : false,
  729.                     origDisplay : '',
  730.                     origLayout: '',
  731.                     origHeight : 0,
  732.                     newHeight : 0,
  733.                     isTouch : false,
  734.                     resetDelay : 0,
  735.                     failsafe : null,
  736.  
  737.                     // CSS
  738.                    
  739.                     prefix : '',
  740.                     easingFallback : 'ease-in-out',
  741.                     transition : {},
  742.                     perspective : {},
  743.                     clean : {},
  744.                     fade : '1',
  745.                     scale : '',
  746.                     rotateX : '',
  747.                     rotateY : '',
  748.                     rotateZ : '',
  749.                     blur : '',
  750.                     grayscale : ''
  751.                 };
  752.                
  753.                 if(settings){
  754.                     $.extend(config, settings);
  755.                 };
  756.  
  757.                 // ADD CONFIG OBJECT TO CONTAINER OBJECT PER INSTANTIATION
  758.                
  759.                 this.config = config;
  760.                
  761.                 // DETECT TOUCH
  762.                
  763.                 $.support.touch = 'ontouchend' in document;
  764.  
  765.                 if ($.support.touch) {
  766.                     config.isTouch = true;
  767.                     config.resetDelay = 350;
  768.                 };
  769.                
  770.                 // LOCALIZE CONTAINER
  771.    
  772.                 config.container = $(this);
  773.                 var $cont = config.container;
  774.                
  775.                 // GET VENDOR PREFIX
  776.                
  777.                 config.prefix = prefix($cont[0]);
  778.                 config.prefix = config.prefix ? '-'+config.prefix.toLowerCase()+'-' : '';
  779.                
  780.                 // CACHE 'DEFAULT' SORTING ORDER
  781.            
  782.                 $cont.find(config.targetSelector).each(function(){
  783.                     config.origOrder.push($(this));
  784.                 });
  785.                
  786.                 // PERFORM SORT ON LOAD
  787.                
  788.                 if(config.sortOnLoad){
  789.                     var sortby, order;
  790.                     if($.isArray(config.sortOnLoad)){
  791.                         sortby = config.sortOnLoad[0], order = config.sortOnLoad[1];
  792.                         $(config.sortSelector+'[data-sort='+config.sortOnLoad[0]+'][data-order='+config.sortOnLoad[1]+']').addClass('active');
  793.                     } else {
  794.                         $(config.sortSelector+'[data-sort='+config.sortOnLoad+']').addClass('active');
  795.                         sortby = config.sortOnLoad, config.sortOnLoad = 'desc';
  796.                     };
  797.                     sort(sortby, order, $cont, config);
  798.                 };
  799.                
  800.                 // BUILD TRANSITION AND PERSPECTIVE OBJECTS
  801.                
  802.                 for(var i = 0; i<2; i++){
  803.                     var a = i==0 ? a = config.prefix : '';
  804.                     config.transition[a+'transition'] = 'all '+config.transitionSpeed+'ms ease-in-out';
  805.                     config.perspective[a+'perspective'] = config.perspectiveDistance+'px';
  806.                     config.perspective[a+'perspective-origin'] = config.perspectiveOrigin;
  807.                 };
  808.                
  809.                 // BUILD TRANSITION CLEANER
  810.                
  811.                 for(var i = 0; i<2; i++){
  812.                     var a = i==0 ? a = config.prefix : '';
  813.                     config.clean[a+'transition'] = 'none';
  814.                 };
  815.    
  816.                 // CHOOSE GRID OR LIST
  817.    
  818.                 if(config.layoutMode == 'list'){
  819.                     $cont.addClass(config.listClass);
  820.                     config.origDisplay = config.targetDisplayList;
  821.                 } else {
  822.                     $cont.addClass(config.gridClass);
  823.                     config.origDisplay = config.targetDisplayGrid;
  824.                 };
  825.                 config.origLayout = config.layoutMode;
  826.                
  827.                 // PARSE 'SHOWONLOAD'
  828.                
  829.                 var showOnLoadArray = config.showOnLoad.split(' ');
  830.                
  831.                 // GIVE ACTIVE FILTER ACTIVE CLASS
  832.                
  833.                 $.each(showOnLoadArray, function(){
  834.                     $(config.filterSelector+'[data-filter="'+this+'"]').addClass('active');
  835.                 });
  836.                
  837.                 // RENAME "ALL" CATEGORY TO "MIX_ALL"
  838.    
  839.                 $cont.find(config.targetSelector).addClass('mix_all');
  840.                 if(showOnLoadArray[0]  == 'all'){
  841.                     showOnLoadArray[0] = 'mix_all',
  842.                     config.showOnLoad = 'mix_all';
  843.                 };
  844.                
  845.                 // FADE IN 'SHOWONLOAD'
  846.                
  847.                 var $showOnLoad = $();
  848.                 $.each(showOnLoadArray, function(){
  849.                     $showOnLoad = $showOnLoad.add($('.'+this))
  850.                 });
  851.                
  852.                 $showOnLoad.each(function(){
  853.                     var $t = $(this);
  854.                     if(config.layoutMode == 'list'){
  855.                         $t.css('display',config.targetDisplayList);
  856.                     } else {
  857.                         $t.css('display',config.targetDisplayGrid);
  858.                     };
  859.                     $t.css(config.transition);
  860.                 });
  861.                
  862.                 // WRAP FADE-IN TO PREVENT RACE CONDITION
  863.                
  864.                 var delay = setTimeout(function(){
  865.                    
  866.                     config.mixing = true;
  867.                    
  868.                     $showOnLoad.css('opacity','1');
  869.                    
  870.                     // CLEAN UP
  871.                    
  872.                     var reset = setTimeout(function(){
  873.                         if(config.layoutMode == 'list'){
  874.                             $showOnLoad.removeStyle(config.prefix+'transition, transition').css({
  875.                                 display: config.targetDisplayList,
  876.                                 opacity: 1
  877.                             });
  878.                         } else {
  879.                             $showOnLoad.removeStyle(config.prefix+'transition, transition').css({
  880.                                 display: config.targetDisplayGrid,
  881.                                 opacity: 1
  882.                             });
  883.                         };
  884.                        
  885.                         // FIRE "ONMIXLOAD" CALLBACK
  886.                        
  887.                         config.mixing = false;
  888.  
  889.                         if(typeof config.onMixLoad == 'function') {
  890.                             var output = config.onMixLoad.call(this, config);
  891.  
  892.                             // UPDATE CONFIG IF DATA RETURNED
  893.  
  894.                             config = output ? output : config;
  895.                         };
  896.                        
  897.                     },config.transitionSpeed);
  898.                 },10);
  899.                
  900.                 // PRESET ACTIVE FILTER
  901.                
  902.                 config.filter = config.showOnLoad;
  903.            
  904.                 // BIND SORT CLICK HANDLERS
  905.            
  906.                 $(config.sortSelector).bind(config.buttonEvent,function(){
  907.                    
  908.                     if(!config.mixing){
  909.                        
  910.                         // PARSE SORT ARGUMENTS FROM BUTTON CLASSES
  911.                        
  912.                         var $t = $(this),
  913.                         sortby = $t.attr('data-sort'),
  914.                         order = $t.attr('data-order');
  915.                        
  916.                         if(!$t.hasClass('active')){
  917.                             $(config.sortSelector).removeClass('active');
  918.                             $t.addClass('active');
  919.                         } else {
  920.                             if(sortby != 'random')return false;
  921.                         };
  922.                        
  923.                         $cont.find(config.targetSelector).each(function(){
  924.                             config.startOrder.push($(this));
  925.                         });
  926.                
  927.                         goMix(config.filter,sortby,order,$cont, config);
  928.                
  929.                     };
  930.                
  931.                 });
  932.  
  933.                 // BIND FILTER CLICK HANDLERS
  934.  
  935.                 $(config.filterSelector).bind(config.buttonEvent,function(){
  936.                
  937.                     if(!config.mixing){
  938.                        
  939.                         var $t = $(this);
  940.                        
  941.                         // PARSE FILTER ARGUMENTS FROM BUTTON CLASSES
  942.        
  943.                         if(config.multiFilter == false){
  944.                            
  945.                             // SINGLE ACTIVE BUTTON
  946.                            
  947.                             $(config.filterSelector).removeClass('active');
  948.                             $t.addClass('active');
  949.                        
  950.                             config.filter = $t.attr('data-filter');
  951.                        
  952.                             $(config.filterSelector+'[data-filter="'+config.filter+'"]').addClass('active');
  953.  
  954.                         } else {
  955.                        
  956.                             // MULTIPLE ACTIVE BUTTONS
  957.                            
  958.                             var thisFilter = $t.attr('data-filter');
  959.                        
  960.                             if($t.hasClass('active')){
  961.                                 $t.removeClass('active');
  962.                                
  963.                                 // REMOVE FILTER FROM SPACE-SEPERATED STRING
  964.                                
  965.                                 var re = new RegExp('(\\s|^)'+thisFilter);
  966.                                 config.filter = config.filter.replace(re,'');
  967.                             } else {
  968.                                
  969.                                 // ADD FILTER TO SPACE-SEPERATED STRING
  970.                                
  971.                                 $t.addClass('active');
  972.                                 config.filter = config.filter+' '+thisFilter;
  973.                                
  974.                             };
  975.                         };
  976.                        
  977.                         // GO MIX
  978.                        
  979.                         goMix(config.filter, null, null, $cont, config);
  980.  
  981.                     };
  982.                
  983.                 });
  984.                    
  985.             });
  986.         },
  987.    
  988.         // "TOGRID" METHOD
  989.    
  990.         toGrid: function(){
  991.             return this.each(function(){
  992.                 var config = this.config;
  993.                 if(config.layoutMode != 'grid'){
  994.                     config.layoutMode = 'grid';
  995.                     goMix(config.filter, null, null, $(this), config);
  996.                 };
  997.             });
  998.         },
  999.    
  1000.         // "TOLIST" METHOD
  1001.    
  1002.         toList: function(){
  1003.             return this.each(function(){
  1004.                 var config = this.config;
  1005.                 if(config.layoutMode != 'list'){
  1006.                     config.layoutMode = 'list';
  1007.                     goMix(config.filter, null, null, $(this), config);
  1008.                 };
  1009.             });
  1010.         },
  1011.    
  1012.         // "FILTER" METHOD
  1013.    
  1014.         filter: function(arg){
  1015.             return this.each(function(){
  1016.                 var config = this.config;
  1017.                 if(!config.mixing){
  1018.                     $(config.filterSelector).removeClass('active');
  1019.                     $(config.filterSelector+'[data-filter="'+arg+'"]').addClass('active');
  1020.                     goMix(arg, null, null, $(this), config);
  1021.                 };
  1022.             });
  1023.         },
  1024.    
  1025.         // "SORT" METHOD
  1026.    
  1027.         sort: function(args){
  1028.             return this.each(function(){
  1029.                 var config = this.config,
  1030.                     $t = $(this);
  1031.                 if(!config.mixing){
  1032.                     $(config.sortSelector).removeClass('active');
  1033.                     if($.isArray(args)){
  1034.                         var sortby = args[0], order = args[1];
  1035.                         $(config.sortSelector+'[data-sort="'+args[0]+'"][data-order="'+args[1]+'"]').addClass('active');
  1036.                     } else {
  1037.                         $(config.sortSelector+'[data-sort="'+args+'"]').addClass('active');
  1038.                         var sortby = args, order = 'desc';
  1039.                     };
  1040.                     $t.find(config.targetSelector).each(function(){
  1041.                         config.startOrder.push($(this));
  1042.                     });
  1043.                    
  1044.                     goMix(config.filter,sortby,order, $t, config);
  1045.                
  1046.                 };
  1047.             });
  1048.         },
  1049.        
  1050.         // "MULTIMIX" METHOD
  1051.        
  1052.         multimix: function(args){
  1053.             return this.each(function(){
  1054.                 var config = this.config,
  1055.                     $t = $(this);
  1056.                     multiOut = {
  1057.                         filter: config.filter,
  1058.                         sort: null,
  1059.                         order: 'desc',
  1060.                         layoutMode: config.layoutMode
  1061.                     };
  1062.                 $.extend(multiOut, args);
  1063.                 if(!config.mixing){
  1064.                     $(config.filterSelector).add(config.sortSelector).removeClass('active');
  1065.                     $(config.filterSelector+'[data-filter="'+multiOut.filter+'"]').addClass('active');
  1066.                     if(typeof multiOut.sort !== 'undefined'){
  1067.                         $(config.sortSelector+'[data-sort="'+multiOut.sort+'"][data-order="'+multiOut.order+'"]').addClass('active');
  1068.                         $t.find(config.targetSelector).each(function(){
  1069.                             config.startOrder.push($(this));
  1070.                         });
  1071.                     };
  1072.                     config.layoutMode = multiOut.layoutMode;
  1073.                     goMix(multiOut.filter,multiOut.sort,multiOut.order, $t, config);
  1074.                 };
  1075.             });
  1076.         },
  1077.        
  1078.         // "REMIX" METHOD
  1079.  
  1080.         remix: function(arg){
  1081.             return this.each(function(){
  1082.                 var config = this.config,
  1083.                     $t = $(this);  
  1084.                 config.origOrder = [];
  1085.                 $t.find(config.targetSelector).each(function(){
  1086.                     var $th = $(this);
  1087.                     $th.addClass('mix_all');
  1088.                     config.origOrder.push($th);
  1089.                 });
  1090.                 if(!config.mixing && typeof arg !== 'undefined'){
  1091.                     $(config.filterSelector).removeClass('active');
  1092.                     $(config.filterSelector+'[data-filter="'+arg+'"]').addClass('active');
  1093.                     goMix(arg, null, null, $t, config);
  1094.                 };
  1095.             });
  1096.         }
  1097.     };
  1098.    
  1099.     // DECLARE PLUGIN
  1100.  
  1101.     $.fn.mixitup = function(method, arg){
  1102.         if (methods[method]) {
  1103.             return methods[method].apply( this, Array.prototype.slice.call(arguments,1));
  1104.         } else if (typeof method === 'object' || ! method){
  1105.             return methods.init.apply( this, arguments );
  1106.         };
  1107.     };
  1108.    
  1109.     /* ==== THE MAGIC ==== */
  1110.    
  1111.     function goMix(filter, sortby, order, $cont, config){
  1112.        
  1113.         // WE ARE NOW MIXING
  1114.  
  1115.         clearInterval(config.failsafe);
  1116.         config.mixing = true;  
  1117.        
  1118.         // APPLY ARGS TO CONFIG
  1119.        
  1120.         config.filter = filter;
  1121.        
  1122.         // FIRE "ONMIXSTART" CALLBACK
  1123.        
  1124.         if(typeof config.onMixStart == 'function') {
  1125.             var output = config.onMixStart.call(this, config);
  1126.            
  1127.             // UPDATE CONFIG IF DATA RETURNED
  1128.            
  1129.             config = output ? output : config;
  1130.         };
  1131.        
  1132.         // SHORT LOCAL VARS
  1133.        
  1134.         var speed = config.transitionSpeed;
  1135.        
  1136.         // REBUILD TRANSITION AND PERSPECTIVE OBJECTS
  1137.        
  1138.         for(var i = 0; i<2; i++){
  1139.             var a = i==0 ? a = config.prefix : '';
  1140.             config.transition[a+'transition'] = 'all '+speed+'ms linear';
  1141.             config.transition[a+'transform'] = a+'translate3d(0,0,0)';
  1142.             config.perspective[a+'perspective'] = config.perspectiveDistance+'px';
  1143.             config.perspective[a+'perspective-origin'] = config.perspectiveOrigin;
  1144.         };
  1145.        
  1146.         // CACHE TARGET ELEMENTS FOR QUICK ACCESS
  1147.        
  1148.         var mixSelector = config.targetSelector,
  1149.         $targets = $cont.find(mixSelector);
  1150.        
  1151.         // ADD DATA OBJECT TO EACH TARGET
  1152.        
  1153.         $targets.each(function(){
  1154.             this.data = {};
  1155.         });
  1156.        
  1157.         // RE-DEFINE CONTAINER INCASE NOT IMMEDIATE PARENT OF TARGET ELEMENTS
  1158.        
  1159.         var $par = $targets.parent();
  1160.    
  1161.         // ADD PERSPECTIVE TO CONTAINER
  1162.        
  1163.         $par.css(config.perspective);
  1164.        
  1165.         // SETUP EASING
  1166.  
  1167.         config.easingFallback = 'ease-in-out';
  1168.         if(config.easing == 'smooth')config.easing = 'cubic-bezier(0.25, 0.46, 0.45, 0.94)';
  1169.         if(config.easing == 'snap')config.easing = 'cubic-bezier(0.77, 0, 0.175, 1)';
  1170.         if(config.easing == 'windback'){
  1171.             config.easing = 'cubic-bezier(0.175, 0.885, 0.320, 1.275)',
  1172.             config.easingFallback = 'cubic-bezier(0.175, 0.885, 0.320, 1)'; // Fall-back for old webkit, with no values > 1 or < 1
  1173.         };
  1174.         if(config.easing == 'windup'){
  1175.             config.easing = 'cubic-bezier(0.6, -0.28, 0.735, 0.045)',
  1176.             config.easingFallback = 'cubic-bezier(0.6, 0.28, 0.735, 0.045)';
  1177.         };
  1178.        
  1179.         // USE LIST SPECIFIC EFFECTS IF DECLARED
  1180.        
  1181.         var effectsOut = config.layoutMode == 'list' && config.listEffects != null ? config.listEffects : config.effects;
  1182.    
  1183.         // BUILD EFFECTS STRINGS & SKIP IF IE8
  1184.    
  1185.         if (Array.prototype.indexOf){
  1186.             config.fade = effectsOut.indexOf('fade') > -1 ? '0' : '';
  1187.             config.scale = effectsOut.indexOf('scale') > -1 ? 'scale(.01)' : '';
  1188.             config.rotateZ = effectsOut.indexOf('rotateZ') > -1 ? 'rotate(180deg)' : '';
  1189.             config.rotateY = effectsOut.indexOf('rotateY') > -1 ? 'rotateY(90deg)' : '';
  1190.             config.rotateX = effectsOut.indexOf('rotateX') > -1 ? 'rotateX(90deg)' : '';
  1191.             config.blur = effectsOut.indexOf('blur') > -1 ? 'blur(8px)' : '';
  1192.             config.grayscale = effectsOut.indexOf('grayscale') > -1 ? 'grayscale(100%)' : '';
  1193.         };
  1194.        
  1195.         // DECLARE NEW JQUERY OBJECTS FOR GROUPING
  1196.        
  1197.         var $show = $(),
  1198.         $hide = $(),
  1199.         filterArray = [],
  1200.         multiDimensional = false;
  1201.        
  1202.         // BUILD FILTER ARRAY(S)
  1203.        
  1204.         if(typeof filter === 'string'){
  1205.            
  1206.             // SINGLE DIMENSIONAL FILTERING
  1207.            
  1208.             filterArray = buildFilterArray(filter);
  1209.            
  1210.         } else {
  1211.            
  1212.             // MULTI DIMENSIONAL FILTERING
  1213.            
  1214.             multiDimensional = true;
  1215.            
  1216.             $.each(filter,function(i){
  1217.                 filterArray[i] = buildFilterArray(this);
  1218.             });
  1219.         };
  1220.  
  1221.         // "OR" LOGIC (DEFAULT)
  1222.        
  1223.         if(config.filterLogic == 'or'){
  1224.            
  1225.             if(filterArray[0] == '') filterArray.shift(); // IF FIRST ITEM IN ARRAY IS AN EMPTY SPACE, DELETE
  1226.            
  1227.             // IF NO ELEMENTS ARE DESIRED THEN HIDE ALL VISIBLE ELEMENTS
  1228.        
  1229.             if(filterArray.length < 1){
  1230.                
  1231.                 $hide = $hide.add($cont.find(mixSelector+':visible'));
  1232.                
  1233.             } else {
  1234.  
  1235.             // ELSE CHECK EACH TARGET ELEMENT FOR ANY FILTER CATEGORY:
  1236.            
  1237.                 $targets.each(function(){
  1238.                     var $t = $(this);
  1239.                     if(!multiDimensional){
  1240.                         // IF HAS ANY FILTER, ADD TO "SHOW" OBJECT
  1241.                         if($t.is('.'+filterArray.join(', .'))){
  1242.                             $show = $show.add($t);
  1243.                         // ELSE IF HAS NO FILTERS, ADD TO "HIDE" OBJECT
  1244.                         } else {
  1245.                             $hide = $hide.add($t);
  1246.                         };
  1247.                     } else {
  1248.                        
  1249.                         var pass = 0;
  1250.                         // FOR EACH DIMENSION
  1251.                        
  1252.                         $.each(filterArray,function(i){
  1253.                             if(this.length){
  1254.                                 if($t.is('.'+this.join(', .'))){
  1255.                                     pass++
  1256.                                 };
  1257.                             } else if(pass > 0){
  1258.                                 pass++;
  1259.                             };
  1260.                         });
  1261.                         // IF PASSES ALL DIMENSIONS, SHOW
  1262.                         if(pass == filterArray.length){
  1263.                             $show = $show.add($t);
  1264.                         // ELSE HIDE
  1265.                         } else {
  1266.                             $hide = $hide.add($t);
  1267.                         };
  1268.                     };
  1269.                 });
  1270.            
  1271.             };
  1272.    
  1273.         } else {
  1274.            
  1275.         // "AND" LOGIC
  1276.            
  1277.             // ADD "MIX_SHOW" CLASS TO ELEMENTS THAT HAVE ALL FILTERS
  1278.            
  1279.             $show = $show.add($par.find(mixSelector+'.'+filterArray.join('.')));
  1280.            
  1281.             // ADD "MIX_HIDE" CLASS TO EVERYTHING ELSE
  1282.            
  1283.             $hide = $hide.add($par.find(mixSelector+':not(.'+filterArray.join('.')+'):visible'));
  1284.         };
  1285.        
  1286.         // GET TOTAL NUMBER OF ELEMENTS TO SHOW
  1287.        
  1288.         var total = $show.length;
  1289.        
  1290.         // DECLARE NEW JQUERY OBJECTS
  1291.  
  1292.         var $tohide = $(),
  1293.         $toshow = $(),
  1294.         $pre = $();
  1295.        
  1296.         // FOR ELEMENTS TO BE HIDDEN, IF NOT ALREADY HIDDEN THEN ADD TO OBJECTS "TOHIDE" AND "PRE"
  1297.         // TO INDICATE PRE-EXISTING ELEMENTS TO BE HIDDEN
  1298.        
  1299.         $hide.each(function(){
  1300.             var $t = $(this);
  1301.             if($t.css('display') != 'none'){
  1302.                 $tohide = $tohide.add($t);
  1303.                 $pre = $pre.add($t);
  1304.             };
  1305.         });
  1306.        
  1307.         // IF ALL ELEMENTS ARE ALREADY SHOWN AND THERE IS NOTHING TO HIDE, AND NOT PERFORMING A LAYOUT CHANGE OR SORT:
  1308.        
  1309.         if($show.filter(':visible').length == total && !$tohide.length && !sortby){
  1310.            
  1311.             if(config.origLayout == config.layoutMode){
  1312.                
  1313.                 // THEN CLEAN UP AND GO HOME
  1314.  
  1315.                 resetFilter();
  1316.                 return false;
  1317.             } else {
  1318.                
  1319.                 // IF ONLY ONE ITEM AND CHANGING FORM GRID TO LIST, MOST LIKELY POSITION WILL NOT CHANGE SO WE'RE DONE
  1320.            
  1321.                 if($show.length == 1){
  1322.                    
  1323.                     if(config.layoutMode == 'list'){
  1324.                         $cont.addClass(config.listClass);
  1325.                         $cont.removeClass(config.gridClass);
  1326.                         $pre.css('display',config.targetDisplayList);
  1327.                     } else {
  1328.                         $cont.addClass(config.gridClass);
  1329.                         $cont.removeClass(config.listClass);
  1330.                         $pre.css('display',config.targetDisplayGrid);
  1331.                     };
  1332.                    
  1333.                     // THEN CLEAN UP AND GO HOME
  1334.  
  1335.                     resetFilter();
  1336.                     return false;
  1337.                 }
  1338.             };
  1339.         };
  1340.        
  1341.         // GET CONTAINER'S STARTING HEIGHT
  1342.  
  1343.         config.origHeight = $par.height();
  1344.        
  1345.         // IF THERE IS SOMETHING TO BE SHOWN:
  1346.  
  1347.         if($show.length){
  1348.            
  1349.             // REMOVE "FAIL CLASS" FROM CONTAINER IF EXISTS
  1350.            
  1351.             $cont.removeClass(config.failClass);
  1352.            
  1353.            
  1354.             // FOR ELEMENTS TO BE SHOWN, IF NOT ALREADY SHOWN THEN ADD TO OBJECTS "TOSHOW" ELSE ADD CLASS "MIX_PRE"
  1355.             // TO INDICATE PRE-EXISTING ELEMENT
  1356.  
  1357.             $show.each(function(){
  1358.                 var $t = $(this);
  1359.                 if($t.css('display') == 'none'){
  1360.                     $toshow = $toshow.add($t)
  1361.                 } else {
  1362.                     $pre = $pre.add($t);
  1363.                 };
  1364.             });
  1365.    
  1366.             // IF NON-ANIMATED LAYOUT MODE TRANSITION:
  1367.        
  1368.             if((config.origLayout != config.layoutMode) && config.animateGridList == false){
  1369.            
  1370.                 // ADD NEW DISPLAY TYPES, CLEAN UP AND GO HOME
  1371.                
  1372.                 if(config.layoutMode == 'list'){
  1373.                     $cont.addClass(config.listClass);
  1374.                     $cont.removeClass(config.gridClass);
  1375.                     $pre.css('display',config.targetDisplayList);
  1376.                 } else {
  1377.                     $cont.addClass(config.gridClass);
  1378.                     $cont.removeClass(config.listClass);
  1379.                     $pre.css('display',config.targetDisplayGrid);
  1380.                 };
  1381.                
  1382.                 resetFilter();
  1383.                 return false;
  1384.             };
  1385.            
  1386.             // IF IE, FUCK OFF, AND THEN CLEAN UP AND GO HOME
  1387.        
  1388.             if(!window.atob){
  1389.                 resetFilter();
  1390.                 return false;
  1391.             };
  1392.            
  1393.             // OVERRIDE ANY EXISTING TRANSITION TIMING FOR CALCULATIONS
  1394.            
  1395.             $targets.css(config.clean);
  1396.            
  1397.             // FOR EACH PRE-EXISTING ELEMENT, ADD STARTING POSITION TO 'ORIGPOS' ARRAY
  1398.            
  1399.             $pre.each(function(){
  1400.                 this.data.origPos = $(this).offset();
  1401.             });
  1402.    
  1403.             // TEMPORARILY SHOW ALL ELEMENTS TO SHOW (THAT ARE NOT ALREADY SHOWN), WITHOUT HIDING ELEMENTS TO HIDE
  1404.             // AND ADD/REMOVE GRID AND LIST CLASSES FROM CONTAINER
  1405.    
  1406.             if(config.layoutMode == 'list'){
  1407.                 $cont.addClass(config.listClass);
  1408.                 $cont.removeClass(config.gridClass);
  1409.                 $toshow.css('display',config.targetDisplayList);
  1410.             } else {
  1411.                 $cont.addClass(config.gridClass);
  1412.                 $cont.removeClass(config.listClass);
  1413.                 $toshow.css('display',config.targetDisplayGrid);
  1414.             };
  1415.            
  1416.             // FOR EACH ELEMENT NOW SHOWN, ADD ITS INTERMEDIATE POSITION TO 'SHOWINTERPOS' ARRAY
  1417.    
  1418.             $toshow.each(function(){
  1419.                 this.data.showInterPos = $(this).offset();
  1420.             });
  1421.            
  1422.             // FOR EACH ELEMENT TO BE HIDDEN, BUT NOT YET HIDDEN, AND NOW MOVED DUE TO SHOWN ELEMENTS,
  1423.             // ADD ITS INTERMEDIATE POSITION TO 'HIDEINTERPOS' ARRAY
  1424.  
  1425.             $tohide.each(function(){
  1426.                 this.data.hideInterPos = $(this).offset();
  1427.             });
  1428.            
  1429.             // FOR EACH PRE-EXISTING ELEMENT, NOW MOVED DUE TO SHOWN ELEMENTS, ADD ITS POSITION TO 'PREINTERPOS' ARRAY
  1430.    
  1431.             $pre.each(function(){
  1432.                 this.data.preInterPos = $(this).offset();
  1433.             });
  1434.            
  1435.             // SET DISPLAY PROPERTY OF PRE-EXISTING ELEMENTS INCASE WE ARE CHANGING LAYOUT MODE
  1436.    
  1437.             if(config.layoutMode == 'list'){
  1438.                 $pre.css('display',config.targetDisplayList);
  1439.             } else {
  1440.                 $pre.css('display',config.targetDisplayGrid);
  1441.             };
  1442.            
  1443.             // IF A SORT ARGUMENT HAS BEEN SENT, RUN SORT FUNCTION SO OBJECTS WILL MOVE TO THEIR FINAL ORDER
  1444.            
  1445.             if(sortby){
  1446.                 sort(sortby, order, $cont, config);
  1447.             };
  1448.            
  1449.             // IF VISIBLE SORT ORDER IS THE SAME (WHICH WOULD NOT TRIGGER A TRANSITION EVENT)
  1450.        
  1451.             if(sortby && compareArr(config.origSort, config.checkSort)){
  1452.                
  1453.                 // THEN CLEAN UP AND GO HOME
  1454.                 resetFilter();
  1455.                 return false;
  1456.             };
  1457.            
  1458.             // TEMPORARILY HIDE ALL SHOWN ELEMENTS TO HIDE
  1459.  
  1460.             $tohide.hide();
  1461.            
  1462.             // FOR EACH ELEMENT TO SHOW, AND NOW MOVED DUE TO HIDDEN ELEMENTS BEING REMOVED,
  1463.             // ADD ITS POSITION TO 'FINALPOS' ARRAY
  1464.            
  1465.             $toshow.each(function(i){
  1466.                 this.data.finalPos = $(this).offset();
  1467.             });
  1468.            
  1469.             // FOR EACH PRE-EXISTING ELEMENT NOW MOVED DUE TO HIDDEN ELEMENTS BEING REMOVED,
  1470.             // ADD ITS POSITION TO 'FINALPREPOS' ARRAY
  1471.    
  1472.             $pre.each(function(){
  1473.                 this.data.finalPrePos = $(this).offset();
  1474.             });
  1475.            
  1476.             // SINCE WE ARE IN OUT FINAL STATE, GET NEW HEIGHT OF CONTAINER
  1477.    
  1478.             config.newHeight = $par.height();
  1479.            
  1480.             // IF A SORT ARGUMENT AS BEEN SENT, RUN SORT FUNCTION 'RESET' TO MOVE ELEMENTS BACK TO THEIR STARTING ORDER
  1481.            
  1482.             if(sortby){
  1483.                 sort('reset', null, $cont, config);
  1484.             };
  1485.            
  1486.             // RE-HIDE ALL ELEMENTS TEMPORARILY SHOWN
  1487.            
  1488.             $toshow.hide();
  1489.            
  1490.             // SET DISPLAY PROPERTY OF PRE-EXISTING ELEMENTS BACK TO THEIR
  1491.             // ORIGINAL PROPERTY, INCASE WE ARE CHANGING LAYOUT MODE
  1492.            
  1493.             $pre.css('display',config.origDisplay);
  1494.            
  1495.             // ADD/REMOVE GRID AND LIST CLASSES FROM CONTAINER
  1496.    
  1497.             if(config.origDisplay == 'block'){
  1498.                 $cont.addClass(config.listClass);
  1499.                 $toshow.css('display', config.targetDisplayList);
  1500.             } else {
  1501.                 $cont.removeClass(config.listClass);
  1502.                 $toshow.css('display', config.targetDisplayGrid);
  1503.             };
  1504.            
  1505.             // IF WE ARE ANIMATING CONTAINER, RESET IT TO ITS STARTING HEIGHT
  1506.        
  1507.             if(config.resizeContainer)$par.css('height', config.origHeight+'px');
  1508.    
  1509.             // ADD TRANSFORMS TO ALL ELEMENTS TO SHOW
  1510.            
  1511.             var toShowCSS = {};
  1512.            
  1513.             for(var i = 0; i<2; i++){
  1514.                 var a = i==0 ? a = config.prefix : '';
  1515.                 toShowCSS[a+'transform'] = config.scale+' '+config.rotateX+' '+config.rotateY+' '+config.rotateZ;
  1516.                 toShowCSS[a+'filter'] = config.blur+' '+config.grayscale;
  1517.             };
  1518.            
  1519.             $toshow.css(toShowCSS);
  1520.    
  1521.             // FOR EACH PRE-EXISTING ELEMENT, SUBTRACT ITS INTERMEDIATE POSITION FROM ITS ORIGINAL POSITION
  1522.             // TO GET ITS STARTING OFFSET
  1523.    
  1524.             $pre.each(function(){
  1525.                 var data = this.data,
  1526.                 $t = $(this);
  1527.                
  1528.                 if ($t.hasClass('mix_tohide')){
  1529.                     data.preTX = data.origPos.left - data.hideInterPos.left;
  1530.                     data.preTY = data.origPos.top - data.hideInterPos.top;
  1531.                 } else {
  1532.                     data.preTX = data.origPos.left - data.preInterPos.left;
  1533.                     data.preTY = data.origPos.top - data.preInterPos.top;
  1534.                 };
  1535.                 var preCSS = {};
  1536.                 for(var i = 0; i<2; i++){
  1537.                     var a = i==0 ? a = config.prefix : '';
  1538.                     preCSS[a+'transform'] = 'translate('+data.preTX+'px,'+data.preTY+'px)';
  1539.                 };
  1540.                
  1541.                 $t.css(preCSS);
  1542.             });
  1543.            
  1544.             // ADD/REMOVE GRID AND LIST CLASSES FROM CONTAINER
  1545.    
  1546.             if(config.layoutMode == 'list'){
  1547.                 $cont.addClass(config.listClass);
  1548.                 $cont.removeClass(config.gridClass);
  1549.             } else {
  1550.                 $cont.addClass(config.gridClass);
  1551.                 $cont.removeClass(config.listClass);
  1552.             };
  1553.            
  1554.             // WRAP ANIMATION FUNCTIONS IN 10ms TIMEOUT TO PREVENT RACE CONDITION
  1555.            
  1556.             var delay = setTimeout(function(){
  1557.        
  1558.                 // APPLY TRANSITION TIMING TO CONTAINER, AND BEGIN ANIMATION TO NEW HEIGHT
  1559.                
  1560.                 if(config.resizeContainer){
  1561.                     var containerCSS = {};
  1562.                     for(var i = 0; i<2; i++){
  1563.                         var a = i==0 ? a = config.prefix : '';
  1564.                         containerCSS[a+'transition'] = 'all '+speed+'ms ease-in-out';
  1565.                         containerCSS['height'] = config.newHeight+'px';
  1566.                     };
  1567.                     $par.css(containerCSS);
  1568.                 };
  1569.    
  1570.                 // BEGIN FADING IN/OUT OF ALL ELEMENTS TO SHOW/HIDE
  1571.                 $tohide.css('opacity',config.fade);
  1572.                 $toshow.css('opacity',1);
  1573.    
  1574.                 // FOR EACH ELEMENT BEING SHOWN, CALCULATE ITS TRAJECTORY BY SUBTRACTING
  1575.                 // ITS INTERMEDIATE POSITION FROM ITS FINAL POSITION.
  1576.                 // ALSO ADD SPEED AND EASING
  1577.                
  1578.                 $toshow.each(function(){
  1579.                     var data = this.data;
  1580.                     data.tX = data.finalPos.left - data.showInterPos.left;
  1581.                     data.tY = data.finalPos.top - data.showInterPos.top;
  1582.                    
  1583.                     var toShowCSS = {};
  1584.                     for(var i = 0; i<2; i++){
  1585.                         var a = i==0 ? a = config.prefix : '';
  1586.                         toShowCSS[a+'transition-property'] = a+'transform, '+a+'filter, opacity';
  1587.                         toShowCSS[a+'transition-timing-function'] = config.easing+', linear, linear';
  1588.                         toShowCSS[a+'transition-duration'] = speed+'ms';
  1589.                         toShowCSS[a+'transition-delay'] = '0';
  1590.                         toShowCSS[a+'transform'] = 'translate('+data.tX+'px,'+data.tY+'px)';
  1591.                         toShowCSS[a+'filter'] = 'none';
  1592.                     };
  1593.                    
  1594.                     $(this).css('-webkit-transition', 'all '+speed+'ms '+config.easingFallback).css(toShowCSS);
  1595.                 });
  1596.                
  1597.                 // FOR EACH PRE-EXISTING ELEMENT, IF IT HAS A FINAL POSITION, CALCULATE
  1598.                 // ITS TRAJETORY BY SUBTRACTING ITS INTERMEDIATE POSITION FROM ITS FINAL POSITION.
  1599.                 // ALSO ADD SPEED AND EASING
  1600.                
  1601.                 $pre.each(function(){
  1602.                     var data = this.data
  1603.                     data.tX = data.finalPrePos.left != 0 ? data.finalPrePos.left - data.preInterPos.left : 0;
  1604.                     data.tY = data.finalPrePos.left != 0 ? data.finalPrePos.top - data.preInterPos.top : 0;
  1605.                    
  1606.                     var preCSS = {};
  1607.                     for(var i = 0; i<2; i++){
  1608.                         var a = i==0 ? a = config.prefix : '';
  1609.                         preCSS[a+'transition'] = 'all '+speed+'ms '+config.easing;
  1610.                         preCSS[a+'transform'] = 'translate('+data.tX+'px,'+data.tY+'px)';
  1611.                     };
  1612.                    
  1613.                     $(this).css('-webkit-transition', 'all '+speed+'ms '+config.easingFallback).css(preCSS);
  1614.                 });
  1615.        
  1616.                 // BEGIN TRANSFORMS ON ALL ELEMENTS TO BE HIDDEN
  1617.                
  1618.                 var toHideCSS = {};
  1619.                 for(var i = 0; i<2; i++){
  1620.                     var a = i==0 ? a = config.prefix : '';
  1621.                     toHideCSS[a+'transition'] = 'all '+speed+'ms '+config.easing+', '+a+'filter '+speed+'ms linear, opacity '+speed+'ms linear';
  1622.                     toHideCSS[a+'transform'] = config.scale+' '+config.rotateX+' '+config.rotateY+' '+config.rotateZ;
  1623.                     toHideCSS[a+'filter'] = config.blur+' '+config.grayscale;
  1624.                     toHideCSS['opacity'] = config.fade;
  1625.                 };
  1626.                
  1627.                 $tohide.css(toHideCSS);
  1628.                
  1629.                 // ALL ANIMATIONS HAVE NOW BEEN STARTED, NOW LISTEN FOR TRANSITION END:
  1630.                
  1631.                 $par.bind('webkitTransitionEnd transitionend otransitionend oTransitionEnd',function(e){
  1632.                    
  1633.                     if (e.originalEvent.propertyName.indexOf('transform') > -1 || e.originalEvent.propertyName.indexOf('opacity') > -1){
  1634.                        
  1635.                         if(mixSelector.indexOf('.') > -1){
  1636.                        
  1637.                         // IF MIXSELECTOR IS A CLASS NAME
  1638.                        
  1639.                             if($(e.target).hasClass(mixSelector.replace('.',''))){
  1640.                                 resetFilter();
  1641.                             };
  1642.                        
  1643.                         } else {
  1644.                            
  1645.                         // IF MIXSELECTOR IS A TAG
  1646.                        
  1647.                             if($(e.target).is(mixSelector)){
  1648.                                 resetFilter();
  1649.                             };
  1650.                            
  1651.                         };
  1652.                        
  1653.                     };
  1654.                 });
  1655.    
  1656.             },10);
  1657.            
  1658.             // LAST RESORT EMERGENCY FAILSAFE
  1659.            
  1660.             config.failsafe = setTimeout(function(){
  1661.                 if(config.mixing){
  1662.                     resetFilter();
  1663.                 };
  1664.             }, speed + 400);
  1665.    
  1666.         } else {
  1667.            
  1668.         // ELSE IF NOTHING TO SHOW, AND EVERYTHING TO BE HIDDEN
  1669.        
  1670.             // IF WE ARE RESIZING CONTAINER, SET ITS STARTING HEIGHT
  1671.    
  1672.             if(config.resizeContainer)$par.css('height', config.origHeight+'px');
  1673.            
  1674.             // IF IE, FUCK OFF, AND THEN GO HOME
  1675.            
  1676.             if(!window.atob){
  1677.                 resetFilter();
  1678.                 return false;
  1679.             };
  1680.            
  1681.             // GROUP ALL ELEMENTS TO HIDE INTO JQUERY OBJECT
  1682.            
  1683.             $tohide = $hide;
  1684.            
  1685.             // WRAP ANIMATION FUNCTIONS IN A 10ms DELAY TO PREVENT RACE CONDITION
  1686.    
  1687.             var delay = setTimeout(function(){
  1688.                
  1689.                 // APPLY PERSPECTIVE TO CONTAINER
  1690.    
  1691.                 $par.css(config.perspective);
  1692.                
  1693.                 // APPLY TRANSITION TIMING TO CONTAINER, AND BEGIN ANIMATION TO NEW HEIGHT
  1694.        
  1695.                 if(config.resizeContainer){
  1696.                     var containerCSS = {};
  1697.                     for(var i = 0; i<2; i++){
  1698.                         var a = i==0 ? a = config.prefix : '';
  1699.                         containerCSS[a+'transition'] = 'height '+speed+'ms ease-in-out';
  1700.                         containerCSS['height'] = config.minHeight+'px';
  1701.                     };
  1702.                     $par.css(containerCSS);
  1703.                 };
  1704.    
  1705.                 // APPLY TRANSITION TIMING TO ALL TARGET ELEMENTS
  1706.                
  1707.                 $targets.css(config.transition);
  1708.                
  1709.                 // GET TOTAL NUMBER OF ELEMENTS TO HIDE
  1710.    
  1711.                 var totalHide = $hide.length;
  1712.                
  1713.                 // IF SOMETHING TO HIDE:
  1714.    
  1715.                 if(totalHide){
  1716.                    
  1717.                     // BEGIN TRANSFORMS ON ALL ELEMENTS TO BE HIDDEN
  1718.  
  1719.                     var toHideCSS = {};
  1720.                     for(var i = 0; i<2; i++){
  1721.                         var a = i==0 ? a = config.prefix : '';
  1722.                         toHideCSS[a+'transform'] = config.scale+' '+config.rotateX+' '+config.rotateY+' '+config.rotateZ;
  1723.                         toHideCSS[a+'filter'] = config.blur+' '+config.grayscale;
  1724.                         toHideCSS['opacity'] = config.fade;
  1725.                     };
  1726.  
  1727.                     $tohide.css(toHideCSS);
  1728.                    
  1729.                     // ALL ANIMATIONS HAVE NOW BEEN STARTED, NOW LISTEN FOR TRANSITION END:
  1730.  
  1731.                     $par.bind('webkitTransitionEnd transitionend otransitionend oTransitionEnd',function(e){
  1732.                         if (e.originalEvent.propertyName.indexOf('transform') > -1 || e.originalEvent.propertyName.indexOf('opacity') > -1){
  1733.                             $cont.addClass(config.failClass);
  1734.                             resetFilter();
  1735.                         };
  1736.                     });
  1737.        
  1738.                 } else {
  1739.                    
  1740.                 // ELSE, WE'RE DONE MIXING
  1741.                    
  1742.                     config.mixing = false;
  1743.                 };
  1744.    
  1745.             }, 10);
  1746.         };
  1747.        
  1748.         // CLEAN UP AND RESET FUNCTION
  1749.  
  1750.         function resetFilter(){
  1751.            
  1752.             // UNBIND TRANSITION END EVENTS FROM CONTAINER
  1753.            
  1754.             $par.unbind('webkitTransitionEnd transitionend otransitionend oTransitionEnd');
  1755.            
  1756.             // IF A SORT ARGUMENT HAS BEEN SENT, SORT ELEMENTS TO THEIR FINAL ORDER
  1757.            
  1758.             if(sortby){
  1759.                 sort(sortby, order, $cont, config);
  1760.             };
  1761.            
  1762.             // EMPTY SORTING ARRAYS
  1763.        
  1764.             config.startOrder = [], config.newOrder = [], config.origSort = [], config.checkSort = [];
  1765.        
  1766.             // REMOVE INLINE STYLES FROM ALL TARGET ELEMENTS AND SLAM THE BRAKES ON
  1767.            
  1768.             $targets.removeStyle(
  1769.                 config.prefix+'filter, filter, '+config.prefix+'transform, transform, opacity, display'
  1770.             ).css(config.clean).removeAttr('data-checksum');
  1771.            
  1772.             // BECAUSE IE SUCKS
  1773.            
  1774.             if(!window.atob){
  1775.                 $targets.css({
  1776.                     display: 'none',
  1777.                     opacity: '0'
  1778.                 });
  1779.             };
  1780.            
  1781.             // REMOVE HEIGHT FROM CONTAINER ONLY IF RESIZING
  1782.            
  1783.             var remH = config.resizeContainer ? 'height' : '';
  1784.            
  1785.             // REMOVE INLINE STYLES FROM CONTAINER
  1786.        
  1787.             $par.removeStyle(
  1788.                 config.prefix+'transition, transition, '+config.prefix+'perspective, perspective, '+config.prefix+'perspective-origin, perspective-origin, '+remH
  1789.             );
  1790.            
  1791.             // ADD FINAL DISPLAY PROPERTIES AND OPACITY TO ALL SHOWN ELEMENTS
  1792.             // CACHE CURRENT LAYOUT MODE & SORT FOR NEXT MIX
  1793.            
  1794.             if(config.layoutMode == 'list'){
  1795.                 $show.css({display:config.targetDisplayList, opacity:'1'});
  1796.                 config.origDisplay = config.targetDisplayList;
  1797.             } else {
  1798.                 $show.css({display:config.targetDisplayGrid, opacity:'1'});
  1799.                 config.origDisplay = config.targetDisplayGrid;
  1800.             };
  1801.             config.origLayout = config.layoutMode;
  1802.                
  1803.             var wait = setTimeout(function(){
  1804.                
  1805.                 // LET GO OF THE BRAKES
  1806.                
  1807.                 $targets.removeStyle(config.prefix+'transition, transition');
  1808.            
  1809.                 // WE'RE DONE MIXING
  1810.            
  1811.                 config.mixing = false;
  1812.            
  1813.                 // FIRE "ONMIXEND" CALLBACK
  1814.            
  1815.                 if(typeof config.onMixEnd == 'function') {
  1816.                     var output = config.onMixEnd.call(this, config);
  1817.                
  1818.                     // UPDATE CONFIG IF DATA RETURNED
  1819.                
  1820.                     config = output ? output : config;
  1821.                 };
  1822.             });
  1823.         };
  1824.     };
  1825.    
  1826.     // SORT FUNCTION
  1827.    
  1828.     function sort(sortby, order, $cont, config){
  1829.  
  1830.         // COMPARE BY ATTRIBUTE
  1831.  
  1832.         function compare(a,b) {
  1833.             var sortAttrA = isNaN(a.attr(sortby) * 1) ? a.attr(sortby).toLowerCase() : a.attr(sortby) * 1,
  1834.                 sortAttrB = isNaN(b.attr(sortby) * 1) ? b.attr(sortby).toLowerCase() : b.attr(sortby) * 1;
  1835.             if (sortAttrA < sortAttrB)
  1836.                 return -1;
  1837.             if (sortAttrA > sortAttrB)
  1838.                 return 1;
  1839.             return 0;
  1840.         };
  1841.        
  1842.         // REBUILD DOM
  1843.  
  1844.         function rebuild(element){
  1845.             if(order == 'asc'){
  1846.                 $sortWrapper.prepend(element).prepend(' ');
  1847.             } else {
  1848.                 $sortWrapper.append(element).append(' ');
  1849.             };
  1850.         };
  1851.        
  1852.         // RANDOMIZE ARRAY
  1853.  
  1854.         function arrayShuffle(oldArray){
  1855.             var newArray = oldArray.slice();
  1856.             var len = newArray.length;
  1857.             var i = len;
  1858.             while (i--){
  1859.                 var p = parseInt(Math.random()*len);
  1860.                 var t = newArray[i];
  1861.                 newArray[i] = newArray[p];
  1862.                 newArray[p] = t;
  1863.             };
  1864.             return newArray;
  1865.         };
  1866.        
  1867.         // SORT
  1868.        
  1869.         $cont.find(config.targetSelector).wrapAll('<div class="mix_sorter"/>');
  1870.        
  1871.         var $sortWrapper = $cont.find('.mix_sorter');
  1872.        
  1873.         if(!config.origSort.length){
  1874.             $sortWrapper.find(config.targetSelector+':visible').each(function(){
  1875.                 $(this).wrap('<s/>');
  1876.                 config.origSort.push($(this).parent().html().replace(/\s+/g, ''));
  1877.                 $(this).unwrap();
  1878.             });
  1879.         };
  1880.        
  1881.        
  1882.        
  1883.         $sortWrapper.empty();
  1884.        
  1885.         if(sortby == 'reset'){
  1886.             $.each(config.startOrder,function(){
  1887.                 $sortWrapper.append(this).append(' ');
  1888.             });
  1889.         } else if(sortby == 'default'){
  1890.             $.each(config.origOrder,function(){
  1891.                 rebuild(this);
  1892.             });
  1893.         } else if(sortby == 'random'){
  1894.             if(!config.newOrder.length){
  1895.                 config.newOrder = arrayShuffle(config.startOrder);
  1896.             };
  1897.             $.each(config.newOrder,function(){
  1898.                 $sortWrapper.append(this).append(' ');
  1899.             });
  1900.         } else if(sortby == 'custom'){
  1901.             $.each(order, function(){
  1902.                 rebuild(this);
  1903.             });
  1904.         } else {
  1905.             // SORT BY ATTRIBUTE
  1906.            
  1907.             if(typeof config.origOrder[0].attr(sortby) === 'undefined'){
  1908.                 console.log('No such attribute found. Terminating');
  1909.                 return false;
  1910.             };
  1911.            
  1912.             if(!config.newOrder.length){
  1913.                 $.each(config.origOrder,function(){
  1914.                     config.newOrder.push($(this));
  1915.                 });
  1916.                 config.newOrder.sort(compare);
  1917.             };
  1918.             $.each(config.newOrder,function(){
  1919.                 rebuild(this);
  1920.             });
  1921.            
  1922.         };
  1923.         config.checkSort = [];
  1924.         $sortWrapper.find(config.targetSelector+':visible').each(function(i){
  1925.             var $t = $(this);
  1926.             if(i == 0){
  1927.                
  1928.                 // PREVENT COMPARE RETURNING FALSE POSITIVES ON ELEMENTS WITH NO CLASS/ATTRIBUTES
  1929.                
  1930.                 $t.attr('data-checksum','1');
  1931.             };
  1932.             $t.wrap('<s/>');
  1933.             config.checkSort.push($t.parent().html().replace(/\s+/g, ''));
  1934.             $t.unwrap();
  1935.         });
  1936.        
  1937.         $cont.find(config.targetSelector).unwrap();
  1938.     };
  1939.    
  1940.     // FIND VENDOR PREFIX
  1941.  
  1942.     function prefix(el) {
  1943.         var prefixes = ["Webkit", "Moz", "O", "ms"];
  1944.         for (var i = 0; i < prefixes.length; i++){
  1945.             if (prefixes[i] + "Transition" in el.style){
  1946.                 return prefixes[i];
  1947.             };
  1948.         };
  1949.         return "transition" in el.style ? "" : false;
  1950.     };
  1951.    
  1952.     // REMOVE SPECIFIC STYLES
  1953.    
  1954.     $.fn.removeStyle = function(style){
  1955.         return this.each(function(){
  1956.             var obj = $(this);
  1957.             style = style.replace(/\s+/g, '');
  1958.             var styles = style.split(',');
  1959.             $.each(styles,function(){
  1960.                
  1961.                 var search = new RegExp(this.toString() + '[^;]+;?', 'g');
  1962.                 obj.attr('style', function(i, style){
  1963.                     if(style) return style.replace(search, '');
  1964.                 });
  1965.             });
  1966.         });
  1967.     };
  1968.  
  1969.     // COMPARE ARRAYS
  1970.    
  1971.     function compareArr(a,b){
  1972.         if (a.length != b.length) return false;
  1973.         for (var i = 0; i < b.length; i++){
  1974.             if (a[i].compare) {
  1975.                 if (!a[i].compare(b[i])) return false;
  1976.             };
  1977.             if (a[i] !== b[i]) return false;
  1978.         };
  1979.         return true;
  1980.     };
  1981.    
  1982.     // BUILD FILTER ARRAY(S)
  1983.    
  1984.     function buildFilterArray(str){
  1985.         // CLEAN FILTER STRING
  1986.         str = str.replace(/\s{2,}/g, ' ');
  1987.         // FOR EACH PEROID SEPERATED CLASS NAME, ADD STRING TO FILTER ARRAY
  1988.         var arr = str.split(' ');
  1989.         // IF ALL, REPLACE WITH MIX_ALL
  1990.         $.each(arr,function(i){
  1991.             if(this == 'all')arr[i] = 'mix_all';
  1992.         });
  1993.         if(arr[0] == "")arr.shift();
  1994.         return arr;
  1995.     };
  1996.  
  1997.    
  1998. })(jQuery);
  1999.  
  2000.  
  2001. /*
  2002.  *  jQuery OwlCarousel v1.3.3
  2003.  *
  2004.  *  Copyright (c) 2013 Bartosz Wojciechowski
  2005.  *  http://www.owlgraphic.com/owlcarousel/
  2006.  *
  2007.  *  Licensed under MIT
  2008.  *
  2009.  */
  2010.  
  2011. /*JS Lint helpers: */
  2012. /*global dragMove: false, dragEnd: false, $, jQuery, alert, window, document */
  2013. /*jslint nomen: true, continue:true */
  2014.  
  2015. if (typeof Object.create !== "function") {
  2016.     Object.create = function (obj) {
  2017.         function F() {}
  2018.         F.prototype = obj;
  2019.         return new F();
  2020.     };
  2021. }
  2022. (function ($, window, document) {
  2023.  
  2024.     var Carousel = {
  2025.         init : function (options, el) {
  2026.             var base = this;
  2027.  
  2028.             base.$elem = $(el);
  2029.             base.options = $.extend({}, $.fn.owlCarousel.options, base.$elem.data(), options);
  2030.  
  2031.             base.userOptions = options;
  2032.             base.loadContent();
  2033.         },
  2034.  
  2035.         loadContent : function () {
  2036.             var base = this, url;
  2037.  
  2038.             function getData(data) {
  2039.                 var i, content = "";
  2040.                 if (typeof base.options.jsonSuccess === "function") {
  2041.                     base.options.jsonSuccess.apply(this, [data]);
  2042.                 } else {
  2043.                     for (i in data.owl) {
  2044.                         if (data.owl.hasOwnProperty(i)) {
  2045.                             content += data.owl[i].item;
  2046.                         }
  2047.                     }
  2048.                     base.$elem.html(content);
  2049.                 }
  2050.                 base.logIn();
  2051.             }
  2052.  
  2053.             if (typeof base.options.beforeInit === "function") {
  2054.                 base.options.beforeInit.apply(this, [base.$elem]);
  2055.             }
  2056.  
  2057.             if (typeof base.options.jsonPath === "string") {
  2058.                 url = base.options.jsonPath;
  2059.                 $.getJSON(url, getData);
  2060.             } else {
  2061.                 base.logIn();
  2062.             }
  2063.         },
  2064.  
  2065.         logIn : function () {
  2066.             var base = this;
  2067.  
  2068.             base.$elem.data("owl-originalStyles", base.$elem.attr("style"));
  2069.             base.$elem.data("owl-originalClasses", base.$elem.attr("class"));
  2070.  
  2071.             base.$elem.css({opacity: 0});
  2072.             base.orignalItems = base.options.items;
  2073.             base.checkBrowser();
  2074.             base.wrapperWidth = 0;
  2075.             base.checkVisible = null;
  2076.             base.setVars();
  2077.         },
  2078.  
  2079.         setVars : function () {
  2080.             var base = this;
  2081.             if (base.$elem.children().length === 0) {return false; }
  2082.             base.baseClass();
  2083.             base.eventTypes();
  2084.             base.$userItems = base.$elem.children();
  2085.             base.itemsAmount = base.$userItems.length;
  2086.             base.wrapItems();
  2087.             base.$owlItems = base.$elem.find(".owl-item");
  2088.             base.$owlWrapper = base.$elem.find(".owl-wrapper");
  2089.             base.playDirection = "next";
  2090.             base.prevItem = 0;
  2091.             base.prevArr = [0];
  2092.             base.currentItem = 0;
  2093.             base.customEvents();
  2094.             base.onStartup();
  2095.         },
  2096.  
  2097.         onStartup : function () {
  2098.             var base = this;
  2099.             base.updateItems();
  2100.             base.calculateAll();
  2101.             base.buildControls();
  2102.             base.updateControls();
  2103.             base.response();
  2104.             base.moveEvents();
  2105.             base.stopOnHover();
  2106.             base.owlStatus();
  2107.  
  2108.             if (base.options.transitionStyle !== false) {
  2109.                 base.transitionTypes(base.options.transitionStyle);
  2110.             }
  2111.             if (base.options.autoPlay === true) {
  2112.                 base.options.autoPlay = 5000;
  2113.             }
  2114.             base.play();
  2115.  
  2116.             base.$elem.find(".owl-wrapper").css("display", "block");
  2117.  
  2118.             if (!base.$elem.is(":visible")) {
  2119.                 base.watchVisibility();
  2120.             } else {
  2121.                 base.$elem.css("opacity", 1);
  2122.             }
  2123.             base.onstartup = false;
  2124.             base.eachMoveUpdate();
  2125.             if (typeof base.options.afterInit === "function") {
  2126.                 base.options.afterInit.apply(this, [base.$elem]);
  2127.             }
  2128.         },
  2129.  
  2130.         eachMoveUpdate : function () {
  2131.             var base = this;
  2132.  
  2133.             if (base.options.lazyLoad === true) {
  2134.                 base.lazyLoad();
  2135.             }
  2136.             if (base.options.autoHeight === true) {
  2137.                 base.autoHeight();
  2138.             }
  2139.             base.onVisibleItems();
  2140.  
  2141.             if (typeof base.options.afterAction === "function") {
  2142.                 base.options.afterAction.apply(this, [base.$elem]);
  2143.             }
  2144.         },
  2145.  
  2146.         updateVars : function () {
  2147.             var base = this;
  2148.             if (typeof base.options.beforeUpdate === "function") {
  2149.                 base.options.beforeUpdate.apply(this, [base.$elem]);
  2150.             }
  2151.             base.watchVisibility();
  2152.             base.updateItems();
  2153.             base.calculateAll();
  2154.             base.updatePosition();
  2155.             base.updateControls();
  2156.             base.eachMoveUpdate();
  2157.             if (typeof base.options.afterUpdate === "function") {
  2158.                 base.options.afterUpdate.apply(this, [base.$elem]);
  2159.             }
  2160.         },
  2161.  
  2162.         reload : function () {
  2163.             var base = this;
  2164.             window.setTimeout(function () {
  2165.                 base.updateVars();
  2166.             }, 0);
  2167.         },
  2168.  
  2169.         watchVisibility : function () {
  2170.             var base = this;
  2171.  
  2172.             if (base.$elem.is(":visible") === false) {
  2173.                 base.$elem.css({opacity: 0});
  2174.                 window.clearInterval(base.autoPlayInterval);
  2175.                 window.clearInterval(base.checkVisible);
  2176.             } else {
  2177.                 return false;
  2178.             }
  2179.             base.checkVisible = window.setInterval(function () {
  2180.                 if (base.$elem.is(":visible")) {
  2181.                     base.reload();
  2182.                     base.$elem.animate({opacity: 1}, 200);
  2183.                     window.clearInterval(base.checkVisible);
  2184.                 }
  2185.             }, 500);
  2186.         },
  2187.  
  2188.         wrapItems : function () {
  2189.             var base = this;
  2190.             base.$userItems.wrapAll("<div class=\"owl-wrapper\">").wrap("<div class=\"owl-item\"></div>");
  2191.             base.$elem.find(".owl-wrapper").wrap("<div class=\"owl-wrapper-outer\">");
  2192.             base.wrapperOuter = base.$elem.find(".owl-wrapper-outer");
  2193.             base.$elem.css("display", "block");
  2194.         },
  2195.  
  2196.         baseClass : function () {
  2197.             var base = this,
  2198.                 hasBaseClass = base.$elem.hasClass(base.options.baseClass),
  2199.                 hasThemeClass = base.$elem.hasClass(base.options.theme);
  2200.  
  2201.             if (!hasBaseClass) {
  2202.                 base.$elem.addClass(base.options.baseClass);
  2203.             }
  2204.  
  2205.             if (!hasThemeClass) {
  2206.                 base.$elem.addClass(base.options.theme);
  2207.             }
  2208.         },
  2209.  
  2210.         updateItems : function () {
  2211.             var base = this, width, i;
  2212.  
  2213.             if (base.options.responsive === false) {
  2214.                 return false;
  2215.             }
  2216.             if (base.options.singleItem === true) {
  2217.                 base.options.items = base.orignalItems = 1;
  2218.                 base.options.itemsCustom = false;
  2219.                 base.options.itemsDesktop = false;
  2220.                 base.options.itemsDesktopSmall = false;
  2221.                 base.options.itemsTablet = false;
  2222.                 base.options.itemsTabletSmall = false;
  2223.                 base.options.itemsMobile = false;
  2224.                 return false;
  2225.             }
  2226.  
  2227.             width = $(base.options.responsiveBaseWidth).width();
  2228.  
  2229.             if (width > (base.options.itemsDesktop[0] || base.orignalItems)) {
  2230.                 base.options.items = base.orignalItems;
  2231.             }
  2232.             if (base.options.itemsCustom !== false) {
  2233.                 //Reorder array by screen size
  2234.                 base.options.itemsCustom.sort(function (a, b) {return a[0] - b[0]; });
  2235.  
  2236.                 for (i = 0; i < base.options.itemsCustom.length; i += 1) {
  2237.                     if (base.options.itemsCustom[i][0] <= width) {
  2238.                         base.options.items = base.options.itemsCustom[i][1];
  2239.                     }
  2240.                 }
  2241.  
  2242.             } else {
  2243.  
  2244.                 if (width <= base.options.itemsDesktop[0] && base.options.itemsDesktop !== false) {
  2245.                     base.options.items = base.options.itemsDesktop[1];
  2246.                 }
  2247.  
  2248.                 if (width <= base.options.itemsDesktopSmall[0] && base.options.itemsDesktopSmall !== false) {
  2249.                     base.options.items = base.options.itemsDesktopSmall[1];
  2250.                 }
  2251.  
  2252.                 if (width <= base.options.itemsTablet[0] && base.options.itemsTablet !== false) {
  2253.                     base.options.items = base.options.itemsTablet[1];
  2254.                 }
  2255.  
  2256.                 if (width <= base.options.itemsTabletSmall[0] && base.options.itemsTabletSmall !== false) {
  2257.                     base.options.items = base.options.itemsTabletSmall[1];
  2258.                 }
  2259.  
  2260.                 if (width <= base.options.itemsMobile[0] && base.options.itemsMobile !== false) {
  2261.                     base.options.items = base.options.itemsMobile[1];
  2262.                 }
  2263.             }
  2264.  
  2265.             //if number of items is less than declared
  2266.             if (base.options.items > base.itemsAmount && base.options.itemsScaleUp === true) {
  2267.                 base.options.items = base.itemsAmount;
  2268.             }
  2269.         },
  2270.  
  2271.         response : function () {
  2272.             var base = this,
  2273.                 smallDelay,
  2274.                 lastWindowWidth;
  2275.  
  2276.             if (base.options.responsive !== true) {
  2277.                 return false;
  2278.             }
  2279.             lastWindowWidth = $(window).width();
  2280.  
  2281.             base.resizer = function () {
  2282.                 if ($(window).width() !== lastWindowWidth) {
  2283.                     if (base.options.autoPlay !== false) {
  2284.                         window.clearInterval(base.autoPlayInterval);
  2285.                     }
  2286.                     window.clearTimeout(smallDelay);
  2287.                     smallDelay = window.setTimeout(function () {
  2288.                         lastWindowWidth = $(window).width();
  2289.                         base.updateVars();
  2290.                     }, base.options.responsiveRefreshRate);
  2291.                 }
  2292.             };
  2293.             $(window).resize(base.resizer);
  2294.         },
  2295.  
  2296.         updatePosition : function () {
  2297.             var base = this;
  2298.             base.jumpTo(base.currentItem);
  2299.             if (base.options.autoPlay !== false) {
  2300.                 base.checkAp();
  2301.             }
  2302.         },
  2303.  
  2304.         appendItemsSizes : function () {
  2305.             var base = this,
  2306.                 roundPages = 0,
  2307.                 lastItem = base.itemsAmount - base.options.items;
  2308.  
  2309.             base.$owlItems.each(function (index) {
  2310.                 var $this = $(this);
  2311.                 $this
  2312.                     .css({"width": base.itemWidth})
  2313.                     .data("owl-item", Number(index));
  2314.  
  2315.                 if (index % base.options.items === 0 || index === lastItem) {
  2316.                     if (!(index > lastItem)) {
  2317.                         roundPages += 1;
  2318.                     }
  2319.                 }
  2320.                 $this.data("owl-roundPages", roundPages);
  2321.             });
  2322.         },
  2323.  
  2324.         appendWrapperSizes : function () {
  2325.             var base = this,
  2326.                 width = base.$owlItems.length * base.itemWidth;
  2327.  
  2328.             base.$owlWrapper.css({
  2329.                 "width": width * 2,
  2330.                 "left": 0
  2331.             });
  2332.             base.appendItemsSizes();
  2333.         },
  2334.  
  2335.         calculateAll : function () {
  2336.             var base = this;
  2337.             base.calculateWidth();
  2338.             base.appendWrapperSizes();
  2339.             base.loops();
  2340.             base.max();
  2341.         },
  2342.  
  2343.         calculateWidth : function () {
  2344.             var base = this;
  2345.             base.itemWidth = Math.round(base.$elem.width() / base.options.items);
  2346.         },
  2347.  
  2348.         max : function () {
  2349.             var base = this,
  2350.                 maximum = ((base.itemsAmount * base.itemWidth) - base.options.items * base.itemWidth) * -1;
  2351.             if (base.options.items > base.itemsAmount) {
  2352.                 base.maximumItem = 0;
  2353.                 maximum = 0;
  2354.                 base.maximumPixels = 0;
  2355.             } else {
  2356.                 base.maximumItem = base.itemsAmount - base.options.items;
  2357.                 base.maximumPixels = maximum;
  2358.             }
  2359.             return maximum;
  2360.         },
  2361.  
  2362.         min : function () {
  2363.             return 0;
  2364.         },
  2365.  
  2366.         loops : function () {
  2367.             var base = this,
  2368.                 prev = 0,
  2369.                 elWidth = 0,
  2370.                 i,
  2371.                 item,
  2372.                 roundPageNum;
  2373.  
  2374.             base.positionsInArray = [0];
  2375.             base.pagesInArray = [];
  2376.  
  2377.             for (i = 0; i < base.itemsAmount; i += 1) {
  2378.                 elWidth += base.itemWidth;
  2379.                 base.positionsInArray.push(-elWidth);
  2380.  
  2381.                 if (base.options.scrollPerPage === true) {
  2382.                     item = $(base.$owlItems[i]);
  2383.                     roundPageNum = item.data("owl-roundPages");
  2384.                     if (roundPageNum !== prev) {
  2385.                         base.pagesInArray[prev] = base.positionsInArray[i];
  2386.                         prev = roundPageNum;
  2387.                     }
  2388.                 }
  2389.             }
  2390.         },
  2391.  
  2392.         buildControls : function () {
  2393.             var base = this;
  2394.             if (base.options.navigation === true || base.options.pagination === true) {
  2395.                 base.owlControls = $("<div class=\"owl-controls\"/>").toggleClass("clickable", !base.browser.isTouch).appendTo(base.$elem);
  2396.             }
  2397.             if (base.options.pagination === true) {
  2398.                 base.buildPagination();
  2399.             }
  2400.             if (base.options.navigation === true) {
  2401.                 base.buildButtons();
  2402.             }
  2403.         },
  2404.  
  2405.         buildButtons : function () {
  2406.             var base = this,
  2407.                 buttonsWrapper = $("<div class=\"owl-buttons\"/>");
  2408.             base.owlControls.append(buttonsWrapper);
  2409.  
  2410.             base.buttonPrev = $("<div/>", {
  2411.                 "class" : "owl-prev",
  2412.                 "html" : base.options.navigationText[0] || ""
  2413.             });
  2414.  
  2415.             base.buttonNext = $("<div/>", {
  2416.                 "class" : "owl-next",
  2417.                 "html" : base.options.navigationText[1] || ""
  2418.             });
  2419.  
  2420.             buttonsWrapper
  2421.                 .append(base.buttonPrev)
  2422.                 .append(base.buttonNext);
  2423.  
  2424.             buttonsWrapper.on("touchstart.owlControls mousedown.owlControls", "div[class^=\"owl\"]", function (event) {
  2425.                 event.preventDefault();
  2426.             });
  2427.  
  2428.             buttonsWrapper.on("touchend.owlControls mouseup.owlControls", "div[class^=\"owl\"]", function (event) {
  2429.                 event.preventDefault();
  2430.                 if ($(this).hasClass("owl-next")) {
  2431.                     base.next();
  2432.                 } else {
  2433.                     base.prev();
  2434.                 }
  2435.             });
  2436.         },
  2437.  
  2438.         buildPagination : function () {
  2439.             var base = this;
  2440.  
  2441.             base.paginationWrapper = $("<div class=\"owl-pagination\"/>");
  2442.             base.owlControls.append(base.paginationWrapper);
  2443.  
  2444.             base.paginationWrapper.on("touchend.owlControls mouseup.owlControls", ".owl-page", function (event) {
  2445.                 event.preventDefault();
  2446.                 if (Number($(this).data("owl-page")) !== base.currentItem) {
  2447.                     base.goTo(Number($(this).data("owl-page")), true);
  2448.                 }
  2449.             });
  2450.         },
  2451.  
  2452.         updatePagination : function () {
  2453.             var base = this,
  2454.                 counter,
  2455.                 lastPage,
  2456.                 lastItem,
  2457.                 i,
  2458.                 paginationButton,
  2459.                 paginationButtonInner;
  2460.  
  2461.             if (base.options.pagination === false) {
  2462.                 return false;
  2463.             }
  2464.  
  2465.             base.paginationWrapper.html("");
  2466.  
  2467.             counter = 0;
  2468.             lastPage = base.itemsAmount - base.itemsAmount % base.options.items;
  2469.  
  2470.             for (i = 0; i < base.itemsAmount; i += 1) {
  2471.                 if (i % base.options.items === 0) {
  2472.                     counter += 1;
  2473.                     if (lastPage === i) {
  2474.                         lastItem = base.itemsAmount - base.options.items;
  2475.                     }
  2476.                     paginationButton = $("<div/>", {
  2477.                         "class" : "owl-page"
  2478.                     });
  2479.                     paginationButtonInner = $("<span></span>", {
  2480.                         "text": base.options.paginationNumbers === true ? counter : "",
  2481.                         "class": base.options.paginationNumbers === true ? "owl-numbers" : ""
  2482.                     });
  2483.                     paginationButton.append(paginationButtonInner);
  2484.  
  2485.                     paginationButton.data("owl-page", lastPage === i ? lastItem : i);
  2486.                     paginationButton.data("owl-roundPages", counter);
  2487.  
  2488.                     base.paginationWrapper.append(paginationButton);
  2489.                 }
  2490.             }
  2491.             base.checkPagination();
  2492.         },
  2493.         checkPagination : function () {
  2494.             var base = this;
  2495.             if (base.options.pagination === false) {
  2496.                 return false;
  2497.             }
  2498.             base.paginationWrapper.find(".owl-page").each(function () {
  2499.                 if ($(this).data("owl-roundPages") === $(base.$owlItems[base.currentItem]).data("owl-roundPages")) {
  2500.                     base.paginationWrapper
  2501.                         .find(".owl-page")
  2502.                         .removeClass("active");
  2503.                     $(this).addClass("active");
  2504.                 }
  2505.             });
  2506.         },
  2507.  
  2508.         checkNavigation : function () {
  2509.             var base = this;
  2510.  
  2511.             if (base.options.navigation === false) {
  2512.                 return false;
  2513.             }
  2514.             if (base.options.rewindNav === false) {
  2515.                 if (base.currentItem === 0 && base.maximumItem === 0) {
  2516.                     base.buttonPrev.addClass("disabled");
  2517.                     base.buttonNext.addClass("disabled");
  2518.                 } else if (base.currentItem === 0 && base.maximumItem !== 0) {
  2519.                     base.buttonPrev.addClass("disabled");
  2520.                     base.buttonNext.removeClass("disabled");
  2521.                 } else if (base.currentItem === base.maximumItem) {
  2522.                     base.buttonPrev.removeClass("disabled");
  2523.                     base.buttonNext.addClass("disabled");
  2524.                 } else if (base.currentItem !== 0 && base.currentItem !== base.maximumItem) {
  2525.                     base.buttonPrev.removeClass("disabled");
  2526.                     base.buttonNext.removeClass("disabled");
  2527.                 }
  2528.             }
  2529.         },
  2530.  
  2531.         updateControls : function () {
  2532.             var base = this;
  2533.             base.updatePagination();
  2534.             base.checkNavigation();
  2535.             if (base.owlControls) {
  2536.                 if (base.options.items >= base.itemsAmount) {
  2537.                     base.owlControls.hide();
  2538.                 } else {
  2539.                     base.owlControls.show();
  2540.                 }
  2541.             }
  2542.         },
  2543.  
  2544.         destroyControls : function () {
  2545.             var base = this;
  2546.             if (base.owlControls) {
  2547.                 base.owlControls.remove();
  2548.             }
  2549.         },
  2550.  
  2551.         next : function (speed) {
  2552.             var base = this;
  2553.  
  2554.             if (base.isTransition) {
  2555.                 return false;
  2556.             }
  2557.  
  2558.             base.currentItem += base.options.scrollPerPage === true ? base.options.items : 1;
  2559.             if (base.currentItem > base.maximumItem + (base.options.scrollPerPage === true ? (base.options.items - 1) : 0)) {
  2560.                 if (base.options.rewindNav === true) {
  2561.                     base.currentItem = 0;
  2562.                     speed = "rewind";
  2563.                 } else {
  2564.                     base.currentItem = base.maximumItem;
  2565.                     return false;
  2566.                 }
  2567.             }
  2568.             base.goTo(base.currentItem, speed);
  2569.         },
  2570.  
  2571.         prev : function (speed) {
  2572.             var base = this;
  2573.  
  2574.             if (base.isTransition) {
  2575.                 return false;
  2576.             }
  2577.  
  2578.             if (base.options.scrollPerPage === true && base.currentItem > 0 && base.currentItem < base.options.items) {
  2579.                 base.currentItem = 0;
  2580.             } else {
  2581.                 base.currentItem -= base.options.scrollPerPage === true ? base.options.items : 1;
  2582.             }
  2583.             if (base.currentItem < 0) {
  2584.                 if (base.options.rewindNav === true) {
  2585.                     base.currentItem = base.maximumItem;
  2586.                     speed = "rewind";
  2587.                 } else {
  2588.                     base.currentItem = 0;
  2589.                     return false;
  2590.                 }
  2591.             }
  2592.             base.goTo(base.currentItem, speed);
  2593.         },
  2594.  
  2595.         goTo : function (position, speed, drag) {
  2596.             var base = this,
  2597.                 goToPixel;
  2598.  
  2599.             if (base.isTransition) {
  2600.                 return false;
  2601.             }
  2602.             if (typeof base.options.beforeMove === "function") {
  2603.                 base.options.beforeMove.apply(this, [base.$elem]);
  2604.             }
  2605.             if (position >= base.maximumItem) {
  2606.                 position = base.maximumItem;
  2607.             } else if (position <= 0) {
  2608.                 position = 0;
  2609.             }
  2610.  
  2611.             base.currentItem = base.owl.currentItem = position;
  2612.             if (base.options.transitionStyle !== false && drag !== "drag" && base.options.items === 1 && base.browser.support3d === true) {
  2613.                 base.swapSpeed(0);
  2614.                 if (base.browser.support3d === true) {
  2615.                     base.transition3d(base.positionsInArray[position]);
  2616.                 } else {
  2617.                     base.css2slide(base.positionsInArray[position], 1);
  2618.                 }
  2619.                 base.afterGo();
  2620.                 base.singleItemTransition();
  2621.                 return false;
  2622.             }
  2623.             goToPixel = base.positionsInArray[position];
  2624.  
  2625.             if (base.browser.support3d === true) {
  2626.                 base.isCss3Finish = false;
  2627.  
  2628.                 if (speed === true) {
  2629.                     base.swapSpeed("paginationSpeed");
  2630.                     window.setTimeout(function () {
  2631.                         base.isCss3Finish = true;
  2632.                     }, base.options.paginationSpeed);
  2633.  
  2634.                 } else if (speed === "rewind") {
  2635.                     base.swapSpeed(base.options.rewindSpeed);
  2636.                     window.setTimeout(function () {
  2637.                         base.isCss3Finish = true;
  2638.                     }, base.options.rewindSpeed);
  2639.  
  2640.                 } else {
  2641.                     base.swapSpeed("slideSpeed");
  2642.                     window.setTimeout(function () {
  2643.                         base.isCss3Finish = true;
  2644.                     }, base.options.slideSpeed);
  2645.                 }
  2646.                 base.transition3d(goToPixel);
  2647.             } else {
  2648.                 if (speed === true) {
  2649.                     base.css2slide(goToPixel, base.options.paginationSpeed);
  2650.                 } else if (speed === "rewind") {
  2651.                     base.css2slide(goToPixel, base.options.rewindSpeed);
  2652.                 } else {
  2653.                     base.css2slide(goToPixel, base.options.slideSpeed);
  2654.                 }
  2655.             }
  2656.             base.afterGo();
  2657.         },
  2658.  
  2659.         jumpTo : function (position) {
  2660.             var base = this;
  2661.             if (typeof base.options.beforeMove === "function") {
  2662.                 base.options.beforeMove.apply(this, [base.$elem]);
  2663.             }
  2664.             if (position >= base.maximumItem || position === -1) {
  2665.                 position = base.maximumItem;
  2666.             } else if (position <= 0) {
  2667.                 position = 0;
  2668.             }
  2669.             base.swapSpeed(0);
  2670.             if (base.browser.support3d === true) {
  2671.                 base.transition3d(base.positionsInArray[position]);
  2672.             } else {
  2673.                 base.css2slide(base.positionsInArray[position], 1);
  2674.             }
  2675.             base.currentItem = base.owl.currentItem = position;
  2676.             base.afterGo();
  2677.         },
  2678.  
  2679.         afterGo : function () {
  2680.             var base = this;
  2681.  
  2682.             base.prevArr.push(base.currentItem);
  2683.             base.prevItem = base.owl.prevItem = base.prevArr[base.prevArr.length - 2];
  2684.             base.prevArr.shift(0);
  2685.  
  2686.             if (base.prevItem !== base.currentItem) {
  2687.                 base.checkPagination();
  2688.                 base.checkNavigation();
  2689.                 base.eachMoveUpdate();
  2690.  
  2691.                 if (base.options.autoPlay !== false) {
  2692.                     base.checkAp();
  2693.                 }
  2694.             }
  2695.             if (typeof base.options.afterMove === "function" && base.prevItem !== base.currentItem) {
  2696.                 base.options.afterMove.apply(this, [base.$elem]);
  2697.             }
  2698.         },
  2699.  
  2700.         stop : function () {
  2701.             var base = this;
  2702.             base.apStatus = "stop";
  2703.             window.clearInterval(base.autoPlayInterval);
  2704.         },
  2705.  
  2706.         checkAp : function () {
  2707.             var base = this;
  2708.             if (base.apStatus !== "stop") {
  2709.                 base.play();
  2710.             }
  2711.         },
  2712.  
  2713.         play : function () {
  2714.             var base = this;
  2715.             base.apStatus = "play";
  2716.             if (base.options.autoPlay === false) {
  2717.                 return false;
  2718.             }
  2719.             window.clearInterval(base.autoPlayInterval);
  2720.             base.autoPlayInterval = window.setInterval(function () {
  2721.                 base.next(true);
  2722.             }, base.options.autoPlay);
  2723.         },
  2724.  
  2725.         swapSpeed : function (action) {
  2726.             var base = this;
  2727.             if (action === "slideSpeed") {
  2728.                 base.$owlWrapper.css(base.addCssSpeed(base.options.slideSpeed));
  2729.             } else if (action === "paginationSpeed") {
  2730.                 base.$owlWrapper.css(base.addCssSpeed(base.options.paginationSpeed));
  2731.             } else if (typeof action !== "string") {
  2732.                 base.$owlWrapper.css(base.addCssSpeed(action));
  2733.             }
  2734.         },
  2735.  
  2736.         addCssSpeed : function (speed) {
  2737.             return {
  2738.                 "-webkit-transition": "all " + speed + "ms ease",
  2739.                 "-moz-transition": "all " + speed + "ms ease",
  2740.                 "-o-transition": "all " + speed + "ms ease",
  2741.                 "transition": "all " + speed + "ms ease"
  2742.             };
  2743.         },
  2744.  
  2745.         removeTransition : function () {
  2746.             return {
  2747.                 "-webkit-transition": "",
  2748.                 "-moz-transition": "",
  2749.                 "-o-transition": "",
  2750.                 "transition": ""
  2751.             };
  2752.         },
  2753.  
  2754.         doTranslate : function (pixels) {
  2755.             return {
  2756.                 "-webkit-transform": "translate3d(" + pixels + "px, 0px, 0px)",
  2757.                 "-moz-transform": "translate3d(" + pixels + "px, 0px, 0px)",
  2758.                 "-o-transform": "translate3d(" + pixels + "px, 0px, 0px)",
  2759.                 "-ms-transform": "translate3d(" + pixels + "px, 0px, 0px)",
  2760.                 "transform": "translate3d(" + pixels + "px, 0px,0px)"
  2761.             };
  2762.         },
  2763.  
  2764.         transition3d : function (value) {
  2765.             var base = this;
  2766.             base.$owlWrapper.css(base.doTranslate(value));
  2767.         },
  2768.  
  2769.         css2move : function (value) {
  2770.             var base = this;
  2771.             base.$owlWrapper.css({"left" : value});
  2772.         },
  2773.  
  2774.         css2slide : function (value, speed) {
  2775.             var base = this;
  2776.  
  2777.             base.isCssFinish = false;
  2778.             base.$owlWrapper.stop(true, true).animate({
  2779.                 "left" : value
  2780.             }, {
  2781.                 duration : speed || base.options.slideSpeed,
  2782.                 complete : function () {
  2783.                     base.isCssFinish = true;
  2784.                 }
  2785.             });
  2786.         },
  2787.  
  2788.         checkBrowser : function () {
  2789.             var base = this,
  2790.                 translate3D = "translate3d(0px, 0px, 0px)",
  2791.                 tempElem = document.createElement("div"),
  2792.                 regex,
  2793.                 asSupport,
  2794.                 support3d,
  2795.                 isTouch;
  2796.  
  2797.             tempElem.style.cssText = "  -moz-transform:" + translate3D +
  2798.                                   "; -ms-transform:"     + translate3D +
  2799.                                   "; -o-transform:"      + translate3D +
  2800.                                   "; -webkit-transform:" + translate3D +
  2801.                                   "; transform:"         + translate3D;
  2802.             regex = /translate3d\(0px, 0px, 0px\)/g;
  2803.             asSupport = tempElem.style.cssText.match(regex);
  2804.             support3d = (asSupport !== null && asSupport.length === 1);
  2805.  
  2806.             isTouch = "ontouchstart" in window || window.navigator.msMaxTouchPoints;
  2807.  
  2808.             base.browser = {
  2809.                 "support3d" : support3d,
  2810.                 "isTouch" : isTouch
  2811.             };
  2812.         },
  2813.  
  2814.         moveEvents : function () {
  2815.             var base = this;
  2816.             if (base.options.mouseDrag !== false || base.options.touchDrag !== false) {
  2817.                 base.gestures();
  2818.                 base.disabledEvents();
  2819.             }
  2820.         },
  2821.  
  2822.         eventTypes : function () {
  2823.             var base = this,
  2824.                 types = ["s", "e", "x"];
  2825.  
  2826.             base.ev_types = {};
  2827.  
  2828.             if (base.options.mouseDrag === true && base.options.touchDrag === true) {
  2829.                 types = [
  2830.                     "touchstart.owl mousedown.owl",
  2831.                     "touchmove.owl mousemove.owl",
  2832.                     "touchend.owl touchcancel.owl mouseup.owl"
  2833.                 ];
  2834.             } else if (base.options.mouseDrag === false && base.options.touchDrag === true) {
  2835.                 types = [
  2836.                     "touchstart.owl",
  2837.                     "touchmove.owl",
  2838.                     "touchend.owl touchcancel.owl"
  2839.                 ];
  2840.             } else if (base.options.mouseDrag === true && base.options.touchDrag === false) {
  2841.                 types = [
  2842.                     "mousedown.owl",
  2843.                     "mousemove.owl",
  2844.                     "mouseup.owl"
  2845.                 ];
  2846.             }
  2847.  
  2848.             base.ev_types.start = types[0];
  2849.             base.ev_types.move = types[1];
  2850.             base.ev_types.end = types[2];
  2851.         },
  2852.  
  2853.         disabledEvents :  function () {
  2854.             var base = this;
  2855.             base.$elem.on("dragstart.owl", function (event) { event.preventDefault(); });
  2856.             base.$elem.on("mousedown.disableTextSelect", function (e) {
  2857.                 return $(e.target).is('input, textarea, select, option');
  2858.             });
  2859.         },
  2860.  
  2861.         gestures : function () {
  2862.             /*jslint unparam: true*/
  2863.             var base = this,
  2864.                 locals = {
  2865.                     offsetX : 0,
  2866.                     offsetY : 0,
  2867.                     baseElWidth : 0,
  2868.                     relativePos : 0,
  2869.                     position: null,
  2870.                     minSwipe : null,
  2871.                     maxSwipe: null,
  2872.                     sliding : null,
  2873.                     dargging: null,
  2874.                     targetElement : null
  2875.                 };
  2876.  
  2877.             base.isCssFinish = true;
  2878.  
  2879.             function getTouches(event) {
  2880.                 if (event.touches !== undefined) {
  2881.                     return {
  2882.                         x : event.touches[0].pageX,
  2883.                         y : event.touches[0].pageY
  2884.                     };
  2885.                 }
  2886.  
  2887.                 if (event.touches === undefined) {
  2888.                     if (event.pageX !== undefined) {
  2889.                         return {
  2890.                             x : event.pageX,
  2891.                             y : event.pageY
  2892.                         };
  2893.                     }
  2894.                     if (event.pageX === undefined) {
  2895.                         return {
  2896.                             x : event.clientX,
  2897.                             y : event.clientY
  2898.                         };
  2899.                     }
  2900.                 }
  2901.             }
  2902.  
  2903.             function swapEvents(type) {
  2904.                 if (type === "on") {
  2905.                     $(document).on(base.ev_types.move, dragMove);
  2906.                     $(document).on(base.ev_types.end, dragEnd);
  2907.                 } else if (type === "off") {
  2908.                     $(document).off(base.ev_types.move);
  2909.                     $(document).off(base.ev_types.end);
  2910.                 }
  2911.             }
  2912.  
  2913.             function dragStart(event) {
  2914.                 var ev = event.originalEvent || event || window.event,
  2915.                     position;
  2916.  
  2917.                 if (ev.which === 3) {
  2918.                     return false;
  2919.                 }
  2920.                 if (base.itemsAmount <= base.options.items) {
  2921.                     return;
  2922.                 }
  2923.                 if (base.isCssFinish === false && !base.options.dragBeforeAnimFinish) {
  2924.                     return false;
  2925.                 }
  2926.                 if (base.isCss3Finish === false && !base.options.dragBeforeAnimFinish) {
  2927.                     return false;
  2928.                 }
  2929.  
  2930.                 if (base.options.autoPlay !== false) {
  2931.                     window.clearInterval(base.autoPlayInterval);
  2932.                 }
  2933.  
  2934.                 if (base.browser.isTouch !== true && !base.$owlWrapper.hasClass("grabbing")) {
  2935.                     base.$owlWrapper.addClass("grabbing");
  2936.                 }
  2937.  
  2938.                 base.newPosX = 0;
  2939.                 base.newRelativeX = 0;
  2940.  
  2941.                 $(this).css(base.removeTransition());
  2942.  
  2943.                 position = $(this).position();
  2944.                 locals.relativePos = position.left;
  2945.  
  2946.                 locals.offsetX = getTouches(ev).x - position.left;
  2947.                 locals.offsetY = getTouches(ev).y - position.top;
  2948.  
  2949.                 swapEvents("on");
  2950.  
  2951.                 locals.sliding = false;
  2952.                 locals.targetElement = ev.target || ev.srcElement;
  2953.             }
  2954.  
  2955.             function dragMove(event) {
  2956.                 var ev = event.originalEvent || event || window.event,
  2957.                     minSwipe,
  2958.                     maxSwipe;
  2959.  
  2960.                 base.newPosX = getTouches(ev).x - locals.offsetX;
  2961.                 base.newPosY = getTouches(ev).y - locals.offsetY;
  2962.                 base.newRelativeX = base.newPosX - locals.relativePos;
  2963.  
  2964.                 if (typeof base.options.startDragging === "function" && locals.dragging !== true && base.newRelativeX !== 0) {
  2965.                     locals.dragging = true;
  2966.                     base.options.startDragging.apply(base, [base.$elem]);
  2967.                 }
  2968.  
  2969.                 if ((base.newRelativeX > 8 || base.newRelativeX < -8) && (base.browser.isTouch === true)) {
  2970.                     if (ev.preventDefault !== undefined) {
  2971.                         ev.preventDefault();
  2972.                     } else {
  2973.                         ev.returnValue = false;
  2974.                     }
  2975.                     locals.sliding = true;
  2976.                 }
  2977.  
  2978.                 if ((base.newPosY > 10 || base.newPosY < -10) && locals.sliding === false) {
  2979.                     $(document).off("touchmove.owl");
  2980.                 }
  2981.  
  2982.                 minSwipe = function () {
  2983.                     return base.newRelativeX / 5;
  2984.                 };
  2985.  
  2986.                 maxSwipe = function () {
  2987.                     return base.maximumPixels + base.newRelativeX / 5;
  2988.                 };
  2989.  
  2990.                 base.newPosX = Math.max(Math.min(base.newPosX, minSwipe()), maxSwipe());
  2991.                 if (base.browser.support3d === true) {
  2992.                     base.transition3d(base.newPosX);
  2993.                 } else {
  2994.                     base.css2move(base.newPosX);
  2995.                 }
  2996.             }
  2997.  
  2998.             function dragEnd(event) {
  2999.                 var ev = event.originalEvent || event || window.event,
  3000.                     newPosition,
  3001.                     handlers,
  3002.                     owlStopEvent;
  3003.  
  3004.                 ev.target = ev.target || ev.srcElement;
  3005.  
  3006.                 locals.dragging = false;
  3007.  
  3008.                 if (base.browser.isTouch !== true) {
  3009.                     base.$owlWrapper.removeClass("grabbing");
  3010.                 }
  3011.  
  3012.                 if (base.newRelativeX < 0) {
  3013.                     base.dragDirection = base.owl.dragDirection = "left";
  3014.                 } else {
  3015.                     base.dragDirection = base.owl.dragDirection = "right";
  3016.                 }
  3017.  
  3018.                 if (base.newRelativeX !== 0) {
  3019.                     newPosition = base.getNewPosition();
  3020.                     base.goTo(newPosition, false, "drag");
  3021.                     if (locals.targetElement === ev.target && base.browser.isTouch !== true) {
  3022.                         $(ev.target).on("click.disable", function (ev) {
  3023.                             ev.stopImmediatePropagation();
  3024.                             ev.stopPropagation();
  3025.                             ev.preventDefault();
  3026.                             $(ev.target).off("click.disable");
  3027.                         });
  3028.                         handlers = $._data(ev.target, "events").click;
  3029.                         owlStopEvent = handlers.pop();
  3030.                         handlers.splice(0, 0, owlStopEvent);
  3031.                     }
  3032.                 }
  3033.                 swapEvents("off");
  3034.             }
  3035.             base.$elem.on(base.ev_types.start, ".owl-wrapper", dragStart);
  3036.         },
  3037.  
  3038.         getNewPosition : function () {
  3039.             var base = this,
  3040.                 newPosition = base.closestItem();
  3041.  
  3042.             if (newPosition > base.maximumItem) {
  3043.                 base.currentItem = base.maximumItem;
  3044.                 newPosition  = base.maximumItem;
  3045.             } else if (base.newPosX >= 0) {
  3046.                 newPosition = 0;
  3047.                 base.currentItem = 0;
  3048.             }
  3049.             return newPosition;
  3050.         },
  3051.         closestItem : function () {
  3052.             var base = this,
  3053.                 array = base.options.scrollPerPage === true ? base.pagesInArray : base.positionsInArray,
  3054.                 goal = base.newPosX,
  3055.                 closest = null;
  3056.  
  3057.             $.each(array, function (i, v) {
  3058.                 if (goal - (base.itemWidth / 20) > array[i + 1] && goal - (base.itemWidth / 20) < v && base.moveDirection() === "left") {
  3059.                     closest = v;
  3060.                     if (base.options.scrollPerPage === true) {
  3061.                         base.currentItem = $.inArray(closest, base.positionsInArray);
  3062.                     } else {
  3063.                         base.currentItem = i;
  3064.                     }
  3065.                 } else if (goal + (base.itemWidth / 20) < v && goal + (base.itemWidth / 20) > (array[i + 1] || array[i] - base.itemWidth) && base.moveDirection() === "right") {
  3066.                     if (base.options.scrollPerPage === true) {
  3067.                         closest = array[i + 1] || array[array.length - 1];
  3068.                         base.currentItem = $.inArray(closest, base.positionsInArray);
  3069.                     } else {
  3070.                         closest = array[i + 1];
  3071.                         base.currentItem = i + 1;
  3072.                     }
  3073.                 }
  3074.             });
  3075.             return base.currentItem;
  3076.         },
  3077.  
  3078.         moveDirection : function () {
  3079.             var base = this,
  3080.                 direction;
  3081.             if (base.newRelativeX < 0) {
  3082.                 direction = "right";
  3083.                 base.playDirection = "next";
  3084.             } else {
  3085.                 direction = "left";
  3086.                 base.playDirection = "prev";
  3087.             }
  3088.             return direction;
  3089.         },
  3090.  
  3091.         customEvents : function () {
  3092.             /*jslint unparam: true*/
  3093.             var base = this;
  3094.             base.$elem.on("owl.next", function () {
  3095.                 base.next();
  3096.             });
  3097.             base.$elem.on("owl.prev", function () {
  3098.                 base.prev();
  3099.             });
  3100.             base.$elem.on("owl.play", function (event, speed) {
  3101.                 base.options.autoPlay = speed;
  3102.                 base.play();
  3103.                 base.hoverStatus = "play";
  3104.             });
  3105.             base.$elem.on("owl.stop", function () {
  3106.                 base.stop();
  3107.                 base.hoverStatus = "stop";
  3108.             });
  3109.             base.$elem.on("owl.goTo", function (event, item) {
  3110.                 base.goTo(item);
  3111.             });
  3112.             base.$elem.on("owl.jumpTo", function (event, item) {
  3113.                 base.jumpTo(item);
  3114.             });
  3115.         },
  3116.  
  3117.         stopOnHover : function () {
  3118.             var base = this;
  3119.             if (base.options.stopOnHover === true && base.browser.isTouch !== true && base.options.autoPlay !== false) {
  3120.                 base.$elem.on("mouseover", function () {
  3121.                     base.stop();
  3122.                 });
  3123.                 base.$elem.on("mouseout", function () {
  3124.                     if (base.hoverStatus !== "stop") {
  3125.                         base.play();
  3126.                     }
  3127.                 });
  3128.             }
  3129.         },
  3130.  
  3131.         lazyLoad : function () {
  3132.             var base = this,
  3133.                 i,
  3134.                 $item,
  3135.                 itemNumber,
  3136.                 $lazyImg,
  3137.                 follow;
  3138.  
  3139.             if (base.options.lazyLoad === false) {
  3140.                 return false;
  3141.             }
  3142.             for (i = 0; i < base.itemsAmount; i += 1) {
  3143.                 $item = $(base.$owlItems[i]);
  3144.  
  3145.                 if ($item.data("owl-loaded") === "loaded") {
  3146.                     continue;
  3147.                 }
  3148.  
  3149.                 itemNumber = $item.data("owl-item");
  3150.                 $lazyImg = $item.find(".lazyOwl");
  3151.  
  3152.                 if (typeof $lazyImg.data("src") !== "string") {
  3153.                     $item.data("owl-loaded", "loaded");
  3154.                     continue;
  3155.                 }
  3156.                 if ($item.data("owl-loaded") === undefined) {
  3157.                     $lazyImg.hide();
  3158.                     $item.addClass("loading").data("owl-loaded", "checked");
  3159.                 }
  3160.                 if (base.options.lazyFollow === true) {
  3161.                     follow = itemNumber >= base.currentItem;
  3162.                 } else {
  3163.                     follow = true;
  3164.                 }
  3165.                 if (follow && itemNumber < base.currentItem + base.options.items && $lazyImg.length) {
  3166.                     base.lazyPreload($item, $lazyImg);
  3167.                 }
  3168.             }
  3169.         },
  3170.  
  3171.         lazyPreload : function ($item, $lazyImg) {
  3172.             var base = this,
  3173.                 iterations = 0,
  3174.                 isBackgroundImg;
  3175.  
  3176.             if ($lazyImg.prop("tagName") === "DIV") {
  3177.                 $lazyImg.css("background-image", "url(" + $lazyImg.data("src") + ")");
  3178.                 isBackgroundImg = true;
  3179.             } else {
  3180.                 $lazyImg[0].src = $lazyImg.data("src");
  3181.             }
  3182.  
  3183.             function showImage() {
  3184.                 $item.data("owl-loaded", "loaded").removeClass("loading");
  3185.                 $lazyImg.removeAttr("data-src");
  3186.                 if (base.options.lazyEffect === "fade") {
  3187.                     $lazyImg.fadeIn(400);
  3188.                 } else {
  3189.                     $lazyImg.show();
  3190.                 }
  3191.                 if (typeof base.options.afterLazyLoad === "function") {
  3192.                     base.options.afterLazyLoad.apply(this, [base.$elem]);
  3193.                 }
  3194.             }
  3195.  
  3196.             function checkLazyImage() {
  3197.                 iterations += 1;
  3198.                 if (base.completeImg($lazyImg.get(0)) || isBackgroundImg === true) {
  3199.                     showImage();
  3200.                 } else if (iterations <= 100) {//if image loads in less than 10 seconds
  3201.                     window.setTimeout(checkLazyImage, 100);
  3202.                 } else {
  3203.                     showImage();
  3204.                 }
  3205.             }
  3206.  
  3207.             checkLazyImage();
  3208.         },
  3209.  
  3210.         autoHeight : function () {
  3211.             var base = this,
  3212.                 $currentimg = $(base.$owlItems[base.currentItem]).find("img"),
  3213.                 iterations;
  3214.  
  3215.             function addHeight() {
  3216.                 var $currentItem = $(base.$owlItems[base.currentItem]).height();
  3217.                 base.wrapperOuter.css("height", $currentItem + "px");
  3218.                 if (!base.wrapperOuter.hasClass("autoHeight")) {
  3219.                     window.setTimeout(function () {
  3220.                         base.wrapperOuter.addClass("autoHeight");
  3221.                     }, 0);
  3222.                 }
  3223.             }
  3224.  
  3225.             function checkImage() {
  3226.                 iterations += 1;
  3227.                 if (base.completeImg($currentimg.get(0))) {
  3228.                     addHeight();
  3229.                 } else if (iterations <= 100) { //if image loads in less than 10 seconds
  3230.                     window.setTimeout(checkImage, 100);
  3231.                 } else {
  3232.                     base.wrapperOuter.css("height", ""); //Else remove height attribute
  3233.                 }
  3234.             }
  3235.  
  3236.             if ($currentimg.get(0) !== undefined) {
  3237.                 iterations = 0;
  3238.                 checkImage();
  3239.             } else {
  3240.                 addHeight();
  3241.             }
  3242.         },
  3243.  
  3244.         completeImg : function (img) {
  3245.             var naturalWidthType;
  3246.  
  3247.             if (!img.complete) {
  3248.                 return false;
  3249.             }
  3250.             naturalWidthType = typeof img.naturalWidth;
  3251.             if (naturalWidthType !== "undefined" && img.naturalWidth === 0) {
  3252.                 return false;
  3253.             }
  3254.             return true;
  3255.         },
  3256.  
  3257.         onVisibleItems : function () {
  3258.             var base = this,
  3259.                 i;
  3260.  
  3261.             if (base.options.addClassActive === true) {
  3262.                 base.$owlItems.removeClass("active");
  3263.             }
  3264.             base.visibleItems = [];
  3265.             for (i = base.currentItem; i < base.currentItem + base.options.items; i += 1) {
  3266.                 base.visibleItems.push(i);
  3267.  
  3268.                 if (base.options.addClassActive === true) {
  3269.                     $(base.$owlItems[i]).addClass("active");
  3270.                 }
  3271.             }
  3272.             base.owl.visibleItems = base.visibleItems;
  3273.         },
  3274.  
  3275.         transitionTypes : function (className) {
  3276.             var base = this;
  3277.             //Currently available: "fade", "backSlide", "goDown", "fadeUp"
  3278.             base.outClass = "owl-" + className + "-out";
  3279.             base.inClass = "owl-" + className + "-in";
  3280.         },
  3281.  
  3282.         singleItemTransition : function () {
  3283.             var base = this,
  3284.                 outClass = base.outClass,
  3285.                 inClass = base.inClass,
  3286.                 $currentItem = base.$owlItems.eq(base.currentItem),
  3287.                 $prevItem = base.$owlItems.eq(base.prevItem),
  3288.                 prevPos = Math.abs(base.positionsInArray[base.currentItem]) + base.positionsInArray[base.prevItem],
  3289.                 origin = Math.abs(base.positionsInArray[base.currentItem]) + base.itemWidth / 2,
  3290.                 animEnd = 'webkitAnimationEnd oAnimationEnd MSAnimationEnd animationend';
  3291.  
  3292.             base.isTransition = true;
  3293.  
  3294.             base.$owlWrapper
  3295.                 .addClass('owl-origin')
  3296.                 .css({
  3297.                     "-webkit-transform-origin" : origin + "px",
  3298.                     "-moz-perspective-origin" : origin + "px",
  3299.                     "perspective-origin" : origin + "px"
  3300.                 });
  3301.             function transStyles(prevPos) {
  3302.                 return {
  3303.                     "position" : "relative",
  3304.                     "left" : prevPos + "px"
  3305.                 };
  3306.             }
  3307.  
  3308.             $prevItem
  3309.                 .css(transStyles(prevPos, 10))
  3310.                 .addClass(outClass)
  3311.                 .on(animEnd, function () {
  3312.                     base.endPrev = true;
  3313.                     $prevItem.off(animEnd);
  3314.                     base.clearTransStyle($prevItem, outClass);
  3315.                 });
  3316.  
  3317.             $currentItem
  3318.                 .addClass(inClass)
  3319.                 .on(animEnd, function () {
  3320.                     base.endCurrent = true;
  3321.                     $currentItem.off(animEnd);
  3322.                     base.clearTransStyle($currentItem, inClass);
  3323.                 });
  3324.         },
  3325.  
  3326.         clearTransStyle : function (item, classToRemove) {
  3327.             var base = this;
  3328.             item.css({
  3329.                 "position" : "",
  3330.                 "left" : ""
  3331.             }).removeClass(classToRemove);
  3332.  
  3333.             if (base.endPrev && base.endCurrent) {
  3334.                 base.$owlWrapper.removeClass('owl-origin');
  3335.                 base.endPrev = false;
  3336.                 base.endCurrent = false;
  3337.                 base.isTransition = false;
  3338.             }
  3339.         },
  3340.  
  3341.         owlStatus : function () {
  3342.             var base = this;
  3343.             base.owl = {
  3344.                 "userOptions"   : base.userOptions,
  3345.                 "baseElement"   : base.$elem,
  3346.                 "userItems"     : base.$userItems,
  3347.                 "owlItems"      : base.$owlItems,
  3348.                 "currentItem"   : base.currentItem,
  3349.                 "prevItem"      : base.prevItem,
  3350.                 "visibleItems"  : base.visibleItems,
  3351.                 "isTouch"       : base.browser.isTouch,
  3352.                 "browser"       : base.browser,
  3353.                 "dragDirection" : base.dragDirection
  3354.             };
  3355.         },
  3356.  
  3357.         clearEvents : function () {
  3358.             var base = this;
  3359.             base.$elem.off(".owl owl mousedown.disableTextSelect");
  3360.             $(document).off(".owl owl");
  3361.             $(window).off("resize", base.resizer);
  3362.         },
  3363.  
  3364.         unWrap : function () {
  3365.             var base = this;
  3366.             if (base.$elem.children().length !== 0) {
  3367.                 base.$owlWrapper.unwrap();
  3368.                 base.$userItems.unwrap().unwrap();
  3369.                 if (base.owlControls) {
  3370.                     base.owlControls.remove();
  3371.                 }
  3372.             }
  3373.             base.clearEvents();
  3374.             base.$elem
  3375.                 .attr("style", base.$elem.data("owl-originalStyles") || "")
  3376.                 .attr("class", base.$elem.data("owl-originalClasses"));
  3377.         },
  3378.  
  3379.         destroy : function () {
  3380.             var base = this;
  3381.             base.stop();
  3382.             window.clearInterval(base.checkVisible);
  3383.             base.unWrap();
  3384.             base.$elem.removeData();
  3385.         },
  3386.  
  3387.         reinit : function (newOptions) {
  3388.             var base = this,
  3389.                 options = $.extend({}, base.userOptions, newOptions);
  3390.             base.unWrap();
  3391.             base.init(options, base.$elem);
  3392.         },
  3393.  
  3394.         addItem : function (htmlString, targetPosition) {
  3395.             var base = this,
  3396.                 position;
  3397.  
  3398.             if (!htmlString) {return false; }
  3399.  
  3400.             if (base.$elem.children().length === 0) {
  3401.                 base.$elem.append(htmlString);
  3402.                 base.setVars();
  3403.                 return false;
  3404.             }
  3405.             base.unWrap();
  3406.             if (targetPosition === undefined || targetPosition === -1) {
  3407.                 position = -1;
  3408.             } else {
  3409.                 position = targetPosition;
  3410.             }
  3411.             if (position >= base.$userItems.length || position === -1) {
  3412.                 base.$userItems.eq(-1).after(htmlString);
  3413.             } else {
  3414.                 base.$userItems.eq(position).before(htmlString);
  3415.             }
  3416.  
  3417.             base.setVars();
  3418.         },
  3419.  
  3420.         removeItem : function (targetPosition) {
  3421.             var base = this,
  3422.                 position;
  3423.  
  3424.             if (base.$elem.children().length === 0) {
  3425.                 return false;
  3426.             }
  3427.             if (targetPosition === undefined || targetPosition === -1) {
  3428.                 position = -1;
  3429.             } else {
  3430.                 position = targetPosition;
  3431.             }
  3432.  
  3433.             base.unWrap();
  3434.             base.$userItems.eq(position).remove();
  3435.             base.setVars();
  3436.         }
  3437.  
  3438.     };
  3439.  
  3440.     $.fn.owlCarousel = function (options) {
  3441.         return this.each(function () {
  3442.             if ($(this).data("owl-init") === true) {
  3443.                 return false;
  3444.             }
  3445.             $(this).data("owl-init", true);
  3446.             var carousel = Object.create(Carousel);
  3447.             carousel.init(options, this);
  3448.             $.data(this, "owlCarousel", carousel);
  3449.         });
  3450.     };
  3451.  
  3452.     $.fn.owlCarousel.options = {
  3453.  
  3454.         items : 5,
  3455.         itemsCustom : false,
  3456.         itemsDesktop : [1199, 4],
  3457.         itemsDesktopSmall : [979, 3],
  3458.         itemsTablet : [768, 2],
  3459.         itemsTabletSmall : false,
  3460.         itemsMobile : [479, 1],
  3461.         singleItem : false,
  3462.         itemsScaleUp : false,
  3463.  
  3464.         slideSpeed : 200,
  3465.         paginationSpeed : 800,
  3466.         rewindSpeed : 1000,
  3467.  
  3468.         autoPlay : false,
  3469.         stopOnHover : false,
  3470.  
  3471.         navigation : false,
  3472.         navigationText : ["prev", "next"],
  3473.         rewindNav : true,
  3474.         scrollPerPage : false,
  3475.  
  3476.         pagination : true,
  3477.         paginationNumbers : false,
  3478.  
  3479.         responsive : true,
  3480.         responsiveRefreshRate : 200,
  3481.         responsiveBaseWidth : window,
  3482.  
  3483.         baseClass : "owl-carousel",
  3484.         theme : "owl-theme",
  3485.  
  3486.         lazyLoad : false,
  3487.         lazyFollow : true,
  3488.         lazyEffect : "fade",
  3489.  
  3490.         autoHeight : false,
  3491.  
  3492.         jsonPath : false,
  3493.         jsonSuccess : false,
  3494.  
  3495.         dragBeforeAnimFinish : true,
  3496.         mouseDrag : true,
  3497.         touchDrag : true,
  3498.  
  3499.         addClassActive : false,
  3500.         transitionStyle : false,
  3501.  
  3502.         beforeUpdate : false,
  3503.         afterUpdate : false,
  3504.         beforeInit : false,
  3505.         afterInit : false,
  3506.         beforeMove : false,
  3507.         afterMove : false,
  3508.         afterAction : false,
  3509.         startDragging : false,
  3510.         afterLazyLoad: false
  3511.     };
  3512. }(jQuery, window, document));
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!