phcthemes_web_theme_pack 2.0.1 → 2.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e779715cb2bf86969be2d8e1c76f36aa0a577248f5434f0661ed3c1574d6040
-  data.tar.gz: 2c2e99440ff831cd310e8dc4f809636deb0842202984fc9d56074091b053db22
+  metadata.gz: e776f79f9ac5ac96519ca3346633ca86837655b40947a977a86d72e0a96ea120
+  data.tar.gz: b245c1776f17dea87e3ef8874c61a6d99299d663de9b02a08961db1924eccbfc
 SHA512:
-  metadata.gz: 9a97980e4bf1f51c433430ebc316783c0d408a160ad15d0f49fad61f778a9ca55ab4f0e165d40adc8caa6bddfe5b6e4651d429ed31f78490bf46ea3f85119904
-  data.tar.gz: b6700f8dcffa25bfdfaba6c3d0fd19328d565a515455181afedf53d5d080f036223d66de9d669e47707cca4daa7348ed93088e423f6f034cd4c4e545dabb73f3
+  metadata.gz: a6cd58472c0515b287e03b9d114e3f22e44f25690b7f2b8976d72646fb08ecda5467fc7d74836988295885d1c76cfc2cc2e20ab4431ba9779d954fe2366357f6
+  data.tar.gz: 521b37986eb9ea685f2c7d207fea35fd24806f4bcce7927b83490a4d521c0f96e850f7729fee9bb45d9bc10652fbc72fa758ed759bd5ee95c9acb3604c7759cf

data/app/assets/javascripts/phcthemes_web_theme_pack_antlr.js

@@ -13,4 +13,5 @@
 //= require themes/antlr/theme/swiper.min.js
 //= require themes/antlr/theme/lazysizes.min.js
 //= require themes/antlr/theme/wow.min.js
+//= require themes/antlr/theme/sidebar.js
 //= require themes/antlr/theme/scripts.js

data/app/assets/javascripts/phcthemes_web_theme_pack_hostinza.js

@@ -0,0 +1,28 @@
+//= require jquery3
+//= require rails-ujs
+//= require activestorage
+//= require jquery-ui
+//= require common/bootstrap/bootstrap.bundle.js
+//= require common/magnific-popup/jquery.magnific-popup.js
+//= require themes/antlr/theme/owl.carousel.min.js
+//= require themes/hostinza/theme/tweetie.js
+//= require themes/hostinza/theme/jquery.parallax-scroll.js
+//= require themes/hostinza/theme/jquery.parallax.js
+//= require themes/hostinza/theme/hostslide.js
+//= require themes/hostinza/theme/vps-slider-month-products.js
+//= require themes/hostinza/theme/vps-slider-month-settings.js
+//= require themes/hostinza/theme/vps-slider-year-products.js
+//= require themes/hostinza/theme/vps-slider-year-settings.js
+//= require common/rev-slider/jquery.themepunch.tools.min.js
+//= require common/rev-slider/jquery.themepunch.revolution.js
+//= require common/rev-slider/extensions/revolution.extension.actions.js
+//= require common/rev-slider/extensions/revolution.extension.carousel.js
+//= require common/rev-slider/extensions/revolution.extension.kenburn.js
+//= require common/rev-slider/extensions/revolution.extension.layeranimation.js
+//= require common/rev-slider/extensions/revolution.extension.migration.js
+//= require common/rev-slider/extensions/revolution.extension.navigation.js
+//= require common/rev-slider/extensions/revolution.extension.parallax.js
+//= require common/rev-slider/extensions/revolution.extension.slideanims.js
+//= require common/rev-slider/extensions/revolution.extension.video.js
+//= require themes/hostinza/theme/shuffle-letters.js
+//= require themes/hostinza/theme/main.js

data/app/assets/javascripts/themes/antlr/theme/sidebar.js

@@ -0,0 +1,36 @@
+document.addEventListener('DOMContentLoaded', function() {
+    "use strict";
+    sticky();
+});
+/*----------------------*/
+/*   Sticky Sidebar     */
+/*----------------------*/
+function sticky() {
+    $.fn.scrollBottom = function() {
+        return $(document).height() - this.scrollTop() - this.height();
+    };
+    var $el = $('#sidebar');
+    var $window = $(window);
+    var top = $el.parent().position().top;
+    $window.bind("scroll resize", function() {
+        var gap = $window.height() - $el.height() - -35;
+        var visibleFoot = 965 - $window.scrollBottom();
+        var scrollTop = $window.scrollTop()
+        if (scrollTop < top + -35) {
+            $el.css({
+                top: (top - scrollTop) + "px",
+                bottom: "auto"
+            });
+        } else if (visibleFoot > gap) {
+            $el.css({
+                top: "auto",
+                bottom: visibleFoot + "px"
+            });
+        } else {
+            $el.css({
+                top: -35,
+                bottom: "auto"
+            });
+        }
+    }).scroll();
+}

data/app/assets/javascripts/themes/hostinza/theme/hostslide.js

@@ -0,0 +1,94 @@
+(function($) {
+
+    $.fn.xsslide = function(type, plans, currentplan, id, orientation) {
+        if (typeof type != 'string') {
+            console.error("XSSlide: 'type' is not a string");
+            return false;
+        }
+        if (plans[0].length < 2) {
+            console.error("XSSlide: Not enough plans provided");
+            return false;
+        }
+        if (typeof currentplan != 'number') {
+            console.error("XSSlide: 'currentplan' is not a number");
+            return false;
+        }
+        if (typeof id != 'string') {
+            console.error("XSSlide: 'id' is not a string");
+            return false;
+        }
+        if (typeof orientation != 'string') {
+            console.error("XSSlide: 'orientation' is not a string");
+            return false;
+        }
+        if (orientation != 'horizontal' && orientation != 'vertical') {
+            console.error("XSSlide: " + orientation + " is not a valid slider orientation.");
+            return false;
+        }
+        if (type === "single") {
+            for (var i = 0, tot = plans.length; i < tot; i++) {
+                $("." + id + i).each(function() {
+                    if ($(this).is("input")) {
+                        $(this).val(plans[i][currentplan - 1]);
+                    } else {
+                        $(this).html(plans[i][currentplan - 1]);
+                    }
+                });
+            }
+            this.slider({
+                orientation: orientation,
+                value: currentplan,
+                range: "min",
+                min: 1,
+                max: plans[0].length + 1,
+                slide: function(event, ui) {
+                    for (var i = 0, tot = plans.length; i < tot; i++) {
+                        $("." + id + i).each(function() {
+                            if ($(this).is("input")) {
+                                $(this).val(plans[i][ui.value - 1]);
+                            } else {
+                                $(this).html(plans[i][ui.value - 1]);
+                            }
+                        });
+                    }
+                }
+            });
+            return this;
+        } else if (type === "multiple") {
+            for (var i = 0, tot = plans.length; i < tot; i++) {
+                (function(i) {
+                    $("." + id + i + "data").each(function() {
+                        if ($(this).is("input")) {
+                            $(this).val(plans[i][currentplan - 1]);
+                        } else {
+                            $(this).html(plans[i][currentplan - 1]);
+                        }
+                    });
+                    $("." + id + i).slider({
+                        orientation: orientation,
+                        value: currentplan,
+                        range: "min",
+                        min: 1,
+                        max: plans[i].length + 1,
+                        step: 1,
+                        slide: function(event, ui) {
+                            $("." + id + i + "data").each(function() {
+                                if ($(this).is("input")) {
+                                    $(this).val(plans[i][ui.value - 1]);
+                                } else {
+                                    $(this).html(plans[i][ui.value - 1]);
+                                }
+                            });
+                        }
+                    });
+                })(i);
+            }
+            return this;
+        } else {
+            console.error("XSSlide: " + type + " is not a valid slider type.");
+            return false;
+        }
+
+    };
+
+}(jQuery));

data/app/assets/javascripts/themes/hostinza/theme/jquery.parallax-scroll.js

@@ -0,0 +1,185 @@
+$(function() {
+    ParallaxScroll.init();
+});
+
+var ParallaxScroll = {
+    /* PUBLIC VARIABLES */
+    showLogs: false,
+    round: 1000,
+
+    /* PUBLIC FUNCTIONS */
+    init: function() {
+        this._log("init");
+        if (this._inited) {
+            this._log("Already Inited");
+            this._inited = true;
+            return;
+        }
+        this._requestAnimationFrame = (function(){
+          return  window.requestAnimationFrame       || 
+                  window.webkitRequestAnimationFrame || 
+                  window.mozRequestAnimationFrame    || 
+                  window.oRequestAnimationFrame      || 
+                  window.msRequestAnimationFrame     || 
+                  function(/* function */ callback, /* DOMElement */ element){
+                      window.setTimeout(callback, 1000 / 60);
+                  };
+        })();
+        this._onScroll(true);
+    },
+
+    /* PRIVATE VARIABLES */
+    _inited: false,
+    _properties: ['x', 'y', 'z', 'rotateX', 'rotateY', 'rotateZ', 'scaleX', 'scaleY', 'scaleZ', 'scale'],
+    _requestAnimationFrame:null,
+
+    /* PRIVATE FUNCTIONS */
+    _log: function(message) {
+        if (this.showLogs) console.log("Parallax Scroll / " + message);
+    },
+    _onScroll: function(noSmooth) {
+        var scroll = $(document).scrollTop();
+        var windowHeight = $(window).height();
+        this._log("onScroll " + scroll);
+        $("[data-parallax]").each($.proxy(function(index, el) {
+            var $el = $(el);
+            var properties = [];
+            var applyProperties = false;
+            var style = $el.data("style");
+            if (style == undefined) {
+                style = $el.attr("style") || "";
+                $el.data("style", style);
+            }
+            var datas = [$el.data("parallax")];
+            var iData;
+            for(iData = 2; ; iData++) {
+                if($el.data("parallax"+iData)) {
+                    datas.push($el.data("parallax-"+iData));
+                }
+                else {
+                    break;
+                }
+            }
+            var datasLength = datas.length;
+            for(iData = 0; iData < datasLength; iData ++) {
+                var data = datas[iData];
+                var scrollFrom = data["from-scroll"];
+                if (scrollFrom == undefined) scrollFrom = Math.max(0, $(el).offset().top - windowHeight);
+                scrollFrom = scrollFrom | 0;
+                var scrollDistance = data["distance"];
+                var scrollTo = data["to-scroll"];
+                if (scrollDistance == undefined && scrollTo == undefined) scrollDistance = windowHeight;
+                scrollDistance = Math.max(scrollDistance | 0, 1);
+                var easing = data["easing"];
+                var easingReturn = data["easing-return"];
+                if (easing == undefined || !$.easing|| !$.easing[easing]) easing = null;
+                if (easingReturn == undefined || !$.easing|| !$.easing[easingReturn]) easingReturn = easing;
+                if (easing) {
+                    var totalTime = data["duration"];
+                    if (totalTime == undefined) totalTime = scrollDistance;
+                    totalTime = Math.max(totalTime | 0, 1);
+                    var totalTimeReturn = data["duration-return"];
+                    if (totalTimeReturn == undefined) totalTimeReturn = totalTime;
+                    scrollDistance = 1;
+                    var currentTime = $el.data("current-time");
+                    if(currentTime == undefined) currentTime = 0;
+                }
+                if (scrollTo == undefined) scrollTo = scrollFrom + scrollDistance;
+                scrollTo = scrollTo | 0;
+                var smoothness = data["smoothness"];
+                if (smoothness == undefined) smoothness = 30;
+                smoothness = smoothness | 0;
+                if (noSmooth || smoothness == 0) smoothness = 1;
+                smoothness = smoothness | 0;
+                var scrollCurrent = scroll;
+                scrollCurrent = Math.max(scrollCurrent, scrollFrom);
+                scrollCurrent = Math.min(scrollCurrent, scrollTo);
+                if(easing) {
+                    if($el.data("sens") == undefined) $el.data("sens", "back");
+                    if(scrollCurrent>scrollFrom) {
+                        if($el.data("sens") == "back") {
+                            currentTime = 1;
+                            $el.data("sens", "go");
+                        }
+                        else {
+                            currentTime++;
+                        }
+                    }
+                    if(scrollCurrent<scrollTo) {
+                        if($el.data("sens") == "go") {
+                            currentTime = 1;
+                            $el.data("sens", "back");
+                        }
+                        else {
+                            currentTime++;
+                        }
+                    }
+                    if(noSmooth) currentTime = totalTime;
+                    $el.data("current-time", currentTime);
+                }
+                this._properties.map($.proxy(function(prop) {
+                    var defaultProp = 0;
+                    var to = data[prop];
+                    if (to == undefined) return;
+                    if(prop=="scale" || prop=="scaleX" || prop=="scaleY" || prop=="scaleZ" ) {
+                        defaultProp = 1;
+                    }
+                    else {
+                        to = to | 0;
+                    }
+                    var prev = $el.data("_" + prop);
+                    if (prev == undefined) prev = defaultProp;
+                    var next = ((to-defaultProp) * ((scrollCurrent - scrollFrom) / (scrollTo - scrollFrom))) + defaultProp;
+                    var val = prev + (next - prev) / smoothness;
+                    if(easing && currentTime>0 && currentTime<=totalTime) {
+                        var from = defaultProp;
+                        if($el.data("sens") == "back") {
+                            from = to;
+                            to = -to;
+                            easing = easingReturn;
+                            totalTime = totalTimeReturn;
+                        }
+                        val = $.easing[easing](null, currentTime, from, to, totalTime);
+                    }
+                    val = Math.ceil(val * this.round) / this.round;
+                    if(val==prev&&next==to) val = to;
+                    if(!properties[prop]) properties[prop] = 0;
+                    properties[prop] += val;
+                    if (prev != properties[prop]) {
+                        $el.data("_" + prop, properties[prop]);
+                        applyProperties = true;
+                    }
+                }, this));
+            }
+            if (applyProperties) {
+                if (properties["z"] != undefined) {
+                    var perspective = data["perspective"];
+                    if (perspective == undefined) perspective = 800;
+                    var $parent = $el.parent();
+                    if(!$parent.data("style")) $parent.data("style", $parent.attr("style") || "");
+                    $parent.attr("style", "perspective:" + perspective + "px; -webkit-perspective:" + perspective + "px; "+ $parent.data("style"));
+                }
+                if(properties["scaleX"] == undefined) properties["scaleX"] = 1;
+                if(properties["scaleY"] == undefined) properties["scaleY"] = 1;
+                if(properties["scaleZ"] == undefined) properties["scaleZ"] = 1;
+                if (properties["scale"] != undefined) {
+                    properties["scaleX"] *= properties["scale"];
+                    properties["scaleY"] *= properties["scale"];
+                    properties["scaleZ"] *= properties["scale"];
+                }
+                var translate3d = "translate3d(" + (properties["x"] ? properties["x"] : 0) + "px, " + (properties["y"] ? properties["y"] : 0) + "px, " + (properties["z"] ? properties["z"] : 0) + "px)";
+                var rotate3d = "rotateX(" + (properties["rotateX"] ? properties["rotateX"] : 0) + "deg) rotateY(" + (properties["rotateY"] ? properties["rotateY"] : 0) + "deg) rotateZ(" + (properties["rotateZ"] ? properties["rotateZ"] : 0) + "deg)";
+                var scale3d = "scaleX(" + properties["scaleX"] + ") scaleY(" + properties["scaleY"] + ") scaleZ(" + properties["scaleZ"] + ")";
+                var cssTransform = translate3d + " " + rotate3d + " " + scale3d + ";";
+                this._log(cssTransform);
+                $el.attr("style", "transform:" + cssTransform + " -webkit-transform:" + cssTransform + " " + style);
+            }
+        }, this));
+        if(window.requestAnimationFrame) {
+            window.requestAnimationFrame($.proxy(this._onScroll, this, false));
+        }
+        else {
+            this._requestAnimationFrame($.proxy(this._onScroll, this, false));
+        }
+    }
+};

data/app/assets/javascripts/themes/hostinza/theme/jquery.parallax.js

@@ -0,0 +1,521 @@
+/**
+ * jQuery || Zepto Parallax Plugin
+ * @author Matthew Wagerfield - @wagerfield
+ * @description Creates a parallax effect between an array of layers,
+ *              driving the motion from the gyroscope output of a smartdevice.
+ *              If no gyroscope is available, the cursor position is used.
+ */
+;(function($, window, document, undefined) {
+
+  // Strict Mode
+  'use strict';
+
+  // Constants
+  var NAME = 'parallax';
+  var MAGIC_NUMBER = 30;
+  var DEFAULTS = {
+    relativeInput: false,
+    clipRelativeInput: false,
+    calibrationThreshold: 100,
+    calibrationDelay: 500,
+    supportDelay: 500,
+    calibrateX: false,
+    calibrateY: true,
+    invertX: true,
+    invertY: true,
+    limitX: false,
+    limitY: false,
+    scalarX: 10.0,
+    scalarY: 10.0,
+    frictionX: 0.1,
+    frictionY: 0.1,
+    originX: 0.5,
+    originY: 0.5,
+    pointerEvents: true,
+    precision: 1
+  };
+
+  function Plugin(element, options) {
+
+    // DOM Context
+    this.element = element;
+
+    // Selections
+    this.$context = $(element).data('api', this);
+    this.$layers = this.$context.find('.layer');
+
+    // Data Extraction
+    var data = {
+      calibrateX: this.$context.data('calibrate-x') || null,
+      calibrateY: this.$context.data('calibrate-y') || null,
+      invertX: this.$context.data('invert-x') || null,
+      invertY: this.$context.data('invert-y') || null,
+      limitX: parseFloat(this.$context.data('limit-x')) || null,
+      limitY: parseFloat(this.$context.data('limit-y')) || null,
+      scalarX: parseFloat(this.$context.data('scalar-x')) || null,
+      scalarY: parseFloat(this.$context.data('scalar-y')) || null,
+      frictionX: parseFloat(this.$context.data('friction-x')) || null,
+      frictionY: parseFloat(this.$context.data('friction-y')) || null,
+      originX: parseFloat(this.$context.data('origin-x')) || null,
+      originY: parseFloat(this.$context.data('origin-y')) || null,
+      pointerEvents: this.$context.data('pointer-events') || true,
+      precision: parseFloat(this.$context.data('precision')) || 1
+    };
+
+    // Delete Null Data Values
+    for (var key in data) {
+      if (data[key] === null) delete data[key];
+    }
+
+    // Compose Settings Object
+    $.extend(this, DEFAULTS, options, data);
+
+    // States
+    this.calibrationTimer = null;
+    this.calibrationFlag = true;
+    this.enabled = false;
+    this.depthsX = [];
+    this.depthsY = [];
+    this.raf = null;
+
+    // Element Bounds
+    this.bounds = null;
+    this.ex = 0;
+    this.ey = 0;
+    this.ew = 0;
+    this.eh = 0;
+
+    // Element Center
+    this.ecx = 0;
+    this.ecy = 0;
+
+    // Element Range
+    this.erx = 0;
+    this.ery = 0;
+
+    // Calibration
+    this.cx = 0;
+    this.cy = 0;
+
+    // Input
+    this.ix = 0;
+    this.iy = 0;
+
+    // Motion
+    this.mx = 0;
+    this.my = 0;
+
+    // Velocity
+    this.vx = 0;
+    this.vy = 0;
+
+    // Callbacks
+    this.onMouseMove = this.onMouseMove.bind(this);
+    this.onDeviceOrientation = this.onDeviceOrientation.bind(this);
+    this.onOrientationTimer = this.onOrientationTimer.bind(this);
+    this.onCalibrationTimer = this.onCalibrationTimer.bind(this);
+    this.onAnimationFrame = this.onAnimationFrame.bind(this);
+    this.onWindowResize = this.onWindowResize.bind(this);
+
+    // Initialise
+    this.initialise();
+  }
+
+  Plugin.prototype.transformSupport = function(value) {
+    var element = document.createElement('div');
+    var propertySupport = false;
+    var propertyValue = null;
+    var featureSupport = false;
+    var cssProperty = null;
+    var jsProperty = null;
+    for (var i = 0, l = this.vendors.length; i < l; i++) {
+      if (this.vendors[i] !== null) {
+        cssProperty = this.vendors[i][0] + 'transform';
+        jsProperty = this.vendors[i][1] + 'Transform';
+      } else {
+        cssProperty = 'transform';
+        jsProperty = 'transform';
+      }
+      if (element.style[jsProperty] !== undefined) {
+        propertySupport = true;
+        break;
+      }
+    }
+    switch(value) {
+      case '2D':
+        featureSupport = propertySupport;
+        break;
+      case '3D':
+        if (propertySupport) {
+          var body = document.body || document.createElement('body');
+          var documentElement = document.documentElement;
+          var documentOverflow = documentElement.style.overflow;
+          var isCreatedBody = false;
+          if (!document.body) {
+            isCreatedBody = true;
+            documentElement.style.overflow = 'hidden';
+            documentElement.appendChild(body);
+            body.style.overflow = 'hidden';
+            body.style.background = '';
+          }
+          body.appendChild(element);
+          element.style[jsProperty] = 'translate3d(1px,1px,1px)';
+          propertyValue = window.getComputedStyle(element).getPropertyValue(cssProperty);
+          featureSupport = propertyValue !== undefined && propertyValue.length > 0 && propertyValue !== "none";
+          documentElement.style.overflow = documentOverflow;
+          body.removeChild(element);
+          if ( isCreatedBody ) {
+            body.removeAttribute('style');
+            body.parentNode.removeChild(body);
+          }
+        }
+        break;
+    }
+    return featureSupport;
+  };
+
+  Plugin.prototype.ww = null;
+  Plugin.prototype.wh = null;
+  Plugin.prototype.wcx = null;
+  Plugin.prototype.wcy = null;
+  Plugin.prototype.wrx = null;
+  Plugin.prototype.wry = null;
+  Plugin.prototype.portrait = null;
+  Plugin.prototype.desktop = !navigator.userAgent.match(/(iPhone|iPod|iPad|Android|BlackBerry|BB10|mobi|tablet|opera mini|nexus 7)/i);
+  Plugin.prototype.vendors = [null,['-webkit-','webkit'],['-moz-','Moz'],['-o-','O'],['-ms-','ms']];
+  Plugin.prototype.motionSupport = !!window.DeviceMotionEvent;
+  Plugin.prototype.orientationSupport = !!window.DeviceOrientationEvent;
+  Plugin.prototype.orientationStatus = 0;
+  Plugin.prototype.transform2DSupport = Plugin.prototype.transformSupport('2D');
+  Plugin.prototype.transform3DSupport = Plugin.prototype.transformSupport('3D');
+  Plugin.prototype.propertyCache = {};
+
+  Plugin.prototype.initialise = function() {
+
+    // Configure Styles
+    if (this.$context.css('position') === 'static') {
+      this.$context.css({
+        position:'relative'
+      });
+    }
+
+    // Pointer events
+    if(!this.pointerEvents){
+      this.$context.css({
+        pointerEvents: 'none'
+      });
+    }
+
+    // Hardware Accelerate Context
+    this.accelerate(this.$context);
+
+    // Setup
+    this.updateLayers();
+    this.updateDimensions();
+    this.enable();
+    this.queueCalibration(this.calibrationDelay);
+  };
+
+  Plugin.prototype.updateLayers = function() {
+
+    // Cache Layer Elements
+    this.$layers = this.$context.find('.layer');
+    this.depthsX = [];
+    this.depthsY = [];
+
+    // Configure Layer Styles
+    this.$layers.css({
+      position:'absolute',
+      display:'block',
+      left: 0,
+      top: 0
+    });
+    this.$layers.first().css({
+      position:'relative'
+    });
+
+    // Hardware Accelerate Layers
+    this.accelerate(this.$layers);
+
+    // Cache Depths
+    this.$layers.each($.proxy(function(index, element) {
+      //Graceful fallback on depth if depth-x or depth-y is absent
+      var depth = $(element).data('depth') || 0;
+      this.depthsX.push($(element).data('depth-x') || depth);
+      this.depthsY.push($(element).data('depth-y') || depth);
+    }, this));
+  };
+
+  Plugin.prototype.updateDimensions = function() {
+    this.ww = window.innerWidth;
+    this.wh = window.innerHeight;
+    this.wcx = this.ww * this.originX;
+    this.wcy = this.wh * this.originY;
+    this.wrx = Math.max(this.wcx, this.ww - this.wcx);
+    this.wry = Math.max(this.wcy, this.wh - this.wcy);
+  };
+
+  Plugin.prototype.updateBounds = function() {
+    this.bounds = this.element.getBoundingClientRect();
+    this.ex = this.bounds.left;
+    this.ey = this.bounds.top;
+    this.ew = this.bounds.width;
+    this.eh = this.bounds.height;
+    this.ecx = this.ew * this.originX;
+    this.ecy = this.eh * this.originY;
+    this.erx = Math.max(this.ecx, this.ew - this.ecx);
+    this.ery = Math.max(this.ecy, this.eh - this.ecy);
+  };
+
+  Plugin.prototype.queueCalibration = function(delay) {
+    clearTimeout(this.calibrationTimer);
+    this.calibrationTimer = setTimeout(this.onCalibrationTimer, delay);
+  };
+
+  Plugin.prototype.enable = function() {
+    if (!this.enabled) {
+      this.enabled = true;
+      if (this.orientationSupport) {
+        this.portrait = null;
+        window.addEventListener('deviceorientation', this.onDeviceOrientation);
+        setTimeout(this.onOrientationTimer, this.supportDelay);
+      } else {
+        this.cx = 0;
+        this.cy = 0;
+        this.portrait = false;
+        window.addEventListener('mousemove', this.onMouseMove);
+      }
+      window.addEventListener('resize', this.onWindowResize);
+      this.raf = requestAnimationFrame(this.onAnimationFrame);
+    }
+  };
+
+  Plugin.prototype.disable = function() {
+    if (this.enabled) {
+      this.enabled = false;
+      if (this.orientationSupport) {
+        window.removeEventListener('deviceorientation', this.onDeviceOrientation);
+      } else {
+        window.removeEventListener('mousemove', this.onMouseMove);
+      }
+      window.removeEventListener('resize', this.onWindowResize);
+      cancelAnimationFrame(this.raf);
+    }
+  };
+
+  Plugin.prototype.calibrate = function(x, y) {
+    this.calibrateX = x === undefined ? this.calibrateX : x;
+    this.calibrateY = y === undefined ? this.calibrateY : y;
+  };
+
+  Plugin.prototype.invert = function(x, y) {
+    this.invertX = x === undefined ? this.invertX : x;
+    this.invertY = y === undefined ? this.invertY : y;
+  };
+
+  Plugin.prototype.friction = function(x, y) {
+    this.frictionX = x === undefined ? this.frictionX : x;
+    this.frictionY = y === undefined ? this.frictionY : y;
+  };
+
+  Plugin.prototype.scalar = function(x, y) {
+    this.scalarX = x === undefined ? this.scalarX : x;
+    this.scalarY = y === undefined ? this.scalarY : y;
+  };
+
+  Plugin.prototype.limit = function(x, y) {
+    this.limitX = x === undefined ? this.limitX : x;
+    this.limitY = y === undefined ? this.limitY : y;
+  };
+
+  Plugin.prototype.origin = function(x, y) {
+    this.originX = x === undefined ? this.originX : x;
+    this.originY = y === undefined ? this.originY : y;
+  };
+
+  Plugin.prototype.clamp = function(value, min, max) {
+    value = Math.max(value, min);
+    value = Math.min(value, max);
+    return value;
+  };
+
+  Plugin.prototype.css = function(element, property, value) {
+    var jsProperty = this.propertyCache[property];
+    if (!jsProperty) {
+      for (var i = 0, l = this.vendors.length; i < l; i++) {
+        if (this.vendors[i] !== null) {
+          jsProperty = $.camelCase(this.vendors[i][1] + '-' + property);
+        } else {
+          jsProperty = property;
+        }
+        if (element.style[jsProperty] !== undefined) {
+          this.propertyCache[property] = jsProperty;
+          break;
+        }
+      }
+    }
+    element.style[jsProperty] = value;
+  };
+
+  Plugin.prototype.accelerate = function($element) {
+    for (var i = 0, l = $element.length; i < l; i++) {
+      var element = $element[i];
+      this.css(element, 'transform', 'translate3d(0,0,0)');
+      this.css(element, 'transform-style', 'preserve-3d');
+      this.css(element, 'backface-visibility', 'hidden');
+    }
+  };
+
+  Plugin.prototype.setPosition = function(element, x, y) {
+    x += 'px';
+    y += 'px';
+    if (this.transform3DSupport) {
+      this.css(element, 'transform', 'translate3d('+x+','+y+',0)');
+    } else if (this.transform2DSupport) {
+      this.css(element, 'transform', 'translate('+x+','+y+')');
+    } else {
+      element.style.left = x;
+      element.style.top = y;
+    }
+  };
+
+  Plugin.prototype.onOrientationTimer = function(event) {
+    if (this.orientationSupport && this.orientationStatus === 0) {
+      this.disable();
+      this.orientationSupport = false;
+      this.enable();
+    }
+  };
+
+  Plugin.prototype.onCalibrationTimer = function(event) {
+    this.calibrationFlag = true;
+  };
+
+  Plugin.prototype.onWindowResize = function(event) {
+    this.updateDimensions();
+  };
+
+  Plugin.prototype.onAnimationFrame = function() {
+    this.updateBounds();
+    var dx = this.ix - this.cx;
+    var dy = this.iy - this.cy;
+    if ((Math.abs(dx) > this.calibrationThreshold) || (Math.abs(dy) > this.calibrationThreshold)) {
+      this.queueCalibration(0);
+    }
+    if (this.portrait) {
+      this.mx = this.calibrateX ? dy : this.iy;
+      this.my = this.calibrateY ? dx : this.ix;
+    } else {
+      this.mx = this.calibrateX ? dx : this.ix;
+      this.my = this.calibrateY ? dy : this.iy;
+    }
+    this.mx *= this.ew * (this.scalarX / 100);
+    this.my *= this.eh * (this.scalarY / 100);
+    if (!isNaN(parseFloat(this.limitX))) {
+      this.mx = this.clamp(this.mx, -this.limitX, this.limitX);
+    }
+    if (!isNaN(parseFloat(this.limitY))) {
+      this.my = this.clamp(this.my, -this.limitY, this.limitY);
+    }
+    this.vx += (this.mx - this.vx) * this.frictionX;
+    this.vy += (this.my - this.vy) * this.frictionY;
+    for (var i = 0, l = this.$layers.length; i < l; i++) {
+      var depthX = this.depthsX[i];
+      var depthY = this.depthsY[i];
+      var layer = this.$layers[i];
+      var xOffset = this.vx * (depthX * (this.invertX ? -1 : 1));
+      var yOffset = this.vy * (depthY * (this.invertY ? -1 : 1));
+      this.setPosition(layer, xOffset, yOffset);
+    }
+    this.raf = requestAnimationFrame(this.onAnimationFrame);
+  };
+
+  Plugin.prototype.onDeviceOrientation = function(event) {
+
+    // Validate environment and event properties.
+    if (!this.desktop && event.beta !== null && event.gamma !== null) {
+
+      // Set orientation status.
+      this.orientationStatus = 1;
+
+      // Extract Rotation
+      var x = (event.beta  || 0) / MAGIC_NUMBER; //  -90 :: 90
+      var y = (event.gamma || 0) / MAGIC_NUMBER; // -180 :: 180
+
+      // Detect Orientation Change
+      var portrait = window.innerHeight > window.innerWidth;
+      if (this.portrait !== portrait) {
+        this.portrait = portrait;
+        this.calibrationFlag = true;
+      }
+
+      // Set Calibration
+      if (this.calibrationFlag) {
+        this.calibrationFlag = false;
+        this.cx = x;
+        this.cy = y;
+      }
+
+      // Set Input
+      this.ix = x;
+      this.iy = y;
+    }
+  };
+
+  Plugin.prototype.onMouseMove = function(event) {
+
+    // Cache mouse coordinates.
+    var clientX = event.clientX;
+    var clientY = event.clientY;
+
+    // Calculate Mouse Input
+    if (!this.orientationSupport && this.relativeInput) {
+
+      // Clip mouse coordinates inside element bounds.
+      if (this.clipRelativeInput) {
+        clientX = Math.max(clientX, this.ex);
+        clientX = Math.min(clientX, this.ex + this.ew);
+        clientY = Math.max(clientY, this.ey);
+        clientY = Math.min(clientY, this.ey + this.eh);
+      }
+
+      // Calculate input relative to the element.
+      this.ix = (clientX - this.ex - this.ecx) / this.erx;
+      this.iy = (clientY - this.ey - this.ecy) / this.ery;
+
+    } else {
+
+      // Calculate input relative to the window.
+      this.ix = (clientX - this.wcx) / this.wrx;
+      this.iy = (clientY - this.wcy) / this.wry;
+    }
+  };
+
+  var API = {
+    enable: Plugin.prototype.enable,
+    disable: Plugin.prototype.disable,
+    updateLayers: Plugin.prototype.updateLayers,
+    calibrate: Plugin.prototype.calibrate,
+    friction: Plugin.prototype.friction,
+    invert: Plugin.prototype.invert,
+    scalar: Plugin.prototype.scalar,
+    limit: Plugin.prototype.limit,
+    origin: Plugin.prototype.origin
+  };
+
+  $.fn[NAME] = function (value) {
+    var args = arguments;
+    return this.each(function () {
+      var $this = $(this);
+      var plugin = $this.data(NAME);
+      if (!plugin) {
+        plugin = new Plugin(this, value);
+        $this.data(NAME, plugin);
+      }
+      if (API[value]) {
+        plugin[value].apply(plugin, Array.prototype.slice.call(args, 1));
+      }
+    });
+  };
+
+})(window.jQuery || window.Zepto, window, document);